diff --git a/braintrust-sdk/src/main/java/dev/braintrust/trace/AttachmentProcessor.java b/braintrust-sdk/src/main/java/dev/braintrust/trace/AttachmentProcessor.java
new file mode 100644
index 00000000..fd07fecb
--- /dev/null
+++ b/braintrust-sdk/src/main/java/dev/braintrust/trace/AttachmentProcessor.java
@@ -0,0 +1,179 @@
+package dev.braintrust.trace;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import com.fasterxml.jackson.databind.node.TextNode;
+import dev.braintrust.json.BraintrustJsonMapper;
+import java.time.Duration;
+import java.util.Base64;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * Scans JSON content for base64 data URI attachments and replaces them with attachment references
+ * after uploading to S3.
+ *
+ * Package-private; not exposed in the public API.
+ */
+@Slf4j
+class AttachmentProcessor {
+ /**
+ * quick heuristic to determine if the json payload contains a base64 encoded file
+ *
+ *
This is used for performance reasons as a fail-fast to avoid doing a json parse.
+ */
+ static final Pattern BASE64_DATA_URI_PATTERN =
+ Pattern.compile("data:([\\w/\\-.+]+);base64,([A-Za-z0-9+/=]{20,})");
+
+ private final AttachmentUploader uploader;
+
+ AttachmentProcessor(AttachmentUploader uploader) {
+ this.uploader = uploader;
+ }
+
+ /**
+ * Scans a JSON string for base64 data URIs, uploads them, and returns the modified JSON with
+ * attachment references.
+ *
+ * @param json the JSON string to scan
+ * @return the modified JSON with base64 data replaced by attachment references, or the original
+ * JSON if no base64 data was found
+ */
+ String processAndUpload(String json) {
+ if (uploader.isShutdown()
+ || json == null
+ || !BASE64_DATA_URI_PATTERN.matcher(json).find()) {
+ return json;
+ }
+
+ try {
+ JsonNode root = BraintrustJsonMapper.get().readTree(json);
+ AtomicBoolean modified = new AtomicBoolean(false);
+ JsonNode result = replaceBase64Attachments(root, modified);
+ return modified.get() ? BraintrustJsonMapper.get().writeValueAsString(result) : json;
+ } catch (UploaderRejectionException e) {
+ log.debug("uploader optimization failed, falling back to span uploads", e);
+ uploader.shutdown(Duration.ofSeconds(0)); // don't block
+ return json;
+ } catch (Exception e) {
+ throw new RuntimeException("Failed to process attachments in JSON", e);
+ }
+ }
+
+ // NOTE: not concerned with recursion blowing the stack because we're mutating AI vendor
+ // messages which are not deep enough for this to be a concern
+ private JsonNode replaceBase64Attachments(JsonNode node, AtomicBoolean modified) {
+ if (node.isTextual()) {
+ return replaceInText((TextNode) node, modified);
+ } else if (node.isObject()) {
+ ObjectNode objectNode = (ObjectNode) node;
+ ObjectNode result = objectNode.deepCopy();
+ var fieldNames = objectNode.fieldNames();
+ while (fieldNames.hasNext()) {
+ String fieldName = fieldNames.next();
+ JsonNode child = objectNode.get(fieldName);
+ result.set(fieldName, replaceBase64Attachments(child, modified));
+ }
+ return result;
+ } else if (node.isArray()) {
+ ArrayNode arrayNode = (ArrayNode) node;
+ ArrayNode result = arrayNode.deepCopy();
+ for (int i = 0; i < arrayNode.size(); i++) {
+ result.set(i, replaceBase64Attachments(arrayNode.get(i), modified));
+ }
+ return result;
+ }
+ return node;
+ }
+
+ @SneakyThrows
+ private JsonNode replaceInText(TextNode textNode, AtomicBoolean modified) {
+ String value = textNode.asText();
+ Matcher matcher = BASE64_DATA_URI_PATTERN.matcher(value);
+ if (!matcher.find()) {
+ return textNode;
+ }
+ if (!isEntirelyDataUri(value)) {
+ log.debug("found base64 string but text contained extra content {}", value);
+ return textNode;
+ }
+
+ matcher.reset();
+ StringBuilder sb = new StringBuilder();
+ while (matcher.find()) {
+ String contentType = matcher.group(1);
+ String base64Data = matcher.group(2);
+ byte[] data = Base64.getDecoder().decode(base64Data);
+
+ String extension = contentTypeToExtension(contentType);
+ String filename = "attachment" + extension;
+ AttachmentReference ref = AttachmentReference.create(filename, contentType);
+
+ if (!uploader.enqueue(ref, data)) {
+ throw new UploaderRejectionException("uploader rejected attachment upload");
+ }
+
+ String replacement =
+ "{\"type\":\"braintrust_attachment\",\"content_type\":\""
+ + contentType
+ + "\",\"filename\":\""
+ + filename
+ + "\",\"key\":\""
+ + ref.key()
+ + "\"}";
+
+ matcher.appendReplacement(sb, Matcher.quoteReplacement(replacement));
+ }
+ matcher.appendTail(sb);
+
+ modified.set(true);
+
+ return BraintrustJsonMapper.get().readTree(sb.toString());
+ }
+
+ static boolean isEntirelyDataUri(String value) {
+ String trimmed = value.trim();
+ return trimmed.startsWith("data:")
+ && !trimmed.contains("\"")
+ && !trimmed.contains("\\")
+ && !trimmed.contains(" ");
+ }
+
+ private static String contentTypeToExtension(String contentType) {
+ switch (contentType.toLowerCase()) {
+ case "image/png":
+ return ".png";
+ case "image/jpeg":
+ case "image/jpg":
+ return ".jpg";
+ case "image/gif":
+ return ".gif";
+ case "image/webp":
+ return ".webp";
+ case "image/svg+xml":
+ return ".svg";
+ case "application/pdf":
+ return ".pdf";
+ case "text/plain":
+ return ".txt";
+ case "application/json":
+ return ".json";
+ default:
+ String[] parts = contentType.split("/");
+ if (parts.length == 2) {
+ return "." + parts[1].split("[;\\-]")[0];
+ }
+ return "";
+ }
+ }
+
+ private static class UploaderRejectionException extends RuntimeException {
+ public UploaderRejectionException(String message) {
+ super(message);
+ }
+ }
+}
diff --git a/braintrust-sdk/src/main/java/dev/braintrust/trace/AttachmentReference.java b/braintrust-sdk/src/main/java/dev/braintrust/trace/AttachmentReference.java
new file mode 100644
index 00000000..5942540e
--- /dev/null
+++ b/braintrust-sdk/src/main/java/dev/braintrust/trace/AttachmentReference.java
@@ -0,0 +1,33 @@
+package dev.braintrust.trace;
+
+import java.util.Objects;
+import java.util.UUID;
+import javax.annotation.Nonnull;
+
+/**
+ * Represents an attachment reference stored on a span in place of uploaded attachment data.
+ *
+ *
Its shape intentionally matches the cross-SDK Braintrust attachment reference format.
+ */
+record AttachmentReference(
+ @Nonnull String type,
+ @Nonnull String filename,
+ @Nonnull String contentType,
+ @Nonnull String key) {
+
+ private static final String DEFAULT_TYPE = "braintrust_attachment";
+
+ /**
+ * Creates an attachment reference with a generated UUID key.
+ *
+ * @param filename the display filename for the attachment
+ * @param contentType the MIME type of the attachment content
+ * @return a new AttachmentReference with a unique key
+ */
+ static AttachmentReference create(@Nonnull String filename, @Nonnull String contentType) {
+ Objects.requireNonNull(filename, "filename cannot be null");
+ Objects.requireNonNull(contentType, "contentType cannot be null");
+ return new AttachmentReference(
+ DEFAULT_TYPE, filename, contentType, UUID.randomUUID().toString());
+ }
+}
diff --git a/braintrust-sdk/src/main/java/dev/braintrust/trace/AttachmentUploader.java b/braintrust-sdk/src/main/java/dev/braintrust/trace/AttachmentUploader.java
new file mode 100644
index 00000000..6c5bddd7
--- /dev/null
+++ b/braintrust-sdk/src/main/java/dev/braintrust/trace/AttachmentUploader.java
@@ -0,0 +1,297 @@
+package dev.braintrust.trace;
+
+import java.io.IOException;
+import java.time.Duration;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicReference;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * Uploads Braintrust attachments in the background.
+ *
+ *
Implementations accept attachment data via {@link #enqueue}, process them asynchronously, and
+ * support graceful shutdown with {@link #shutdown}.
+ */
+interface AttachmentUploader {
+ /**
+ * Enqueues an attachment for upload.
+ *
+ *
NOTE: if the upload queue is full, this method will block until space becomes available
+ *
+ * @param reference the attachment reference metadata
+ * @param data the attachment data to upload
+ * @return true if the attachment was successfully enqueued for upload. False if the uploader
+ * declined to enqueue the message
+ */
+ boolean enqueue(@Nonnull AttachmentReference reference, @Nonnull byte[] data);
+
+ /** runs force flush with a default timeout */
+ default void forceFlush() {
+ forceFlush(Duration.ofSeconds(30));
+ }
+
+ /**
+ * Waits for all currently enqueued uploads to complete with a timeout.
+ *
+ *
Concurrency note: Items enqueued concurrently with or after this call are not
+ * guaranteed to be included. This is safe because callers that need ordering should enqueue
+ * first, then flush.
+ *
+ * @param timeout the maximum time to wait
+ * @return true if all uploads completed, false if timed out
+ */
+ boolean forceFlush(@Nonnull Duration timeout);
+
+ /** runs shutdown with a default timeout */
+ default void shutdown() {
+ // dropping s3 uploads is a bad user experience so we'll shut down with a very gracious
+ // timeout
+ shutdown(Duration.ofSeconds(120));
+ }
+
+ /**
+ * Shuts down the uploader with a custom timeout.
+ *
+ * @param timeout the maximum time to wait for pending uploads
+ */
+ void shutdown(@Nonnull Duration timeout);
+
+ boolean isShutdown();
+
+ /**
+ * Background uploader for Braintrust attachments that uploads to S3 via signed URLs.
+ *
+ *
Uploads are enqueued and processed by a single-threaded worker that:
+ *
+ *
+ * - Requests a signed upload URL from the Braintrust API
+ *
- Uploads the data to the signed URL
+ *
- Reports the upload status (done/error) to the Braintrust API
+ *
+ *
+ * The uploader starts lazily on first enqueue and can be shut down gracefully.
+ */
+ @Slf4j
+ class S3AttachmentUploader implements AttachmentUploader {
+ private static final int QUEUE_SIZE = 1024;
+
+ private final S3Uploader s3Uploader;
+
+ private final LinkedBlockingQueue queue;
+ private final AtomicReference worker = new AtomicReference<>();
+ private final AtomicReference orgId = new AtomicReference<>();
+
+ // non thread safe fields must be checked and read under the lock
+ private final Object lock = new Object();
+ private boolean rejectNewJobs = false;
+ private boolean workerDone = false;
+ private CountDownLatch currentBatch = new CountDownLatch(1);
+
+ /**
+ * Creates a new attachment uploader.
+ *
+ * @param s3Uploader the S3 uploader for handling attachment uploads
+ */
+ S3AttachmentUploader(@Nonnull S3Uploader s3Uploader) {
+ this.s3Uploader = s3Uploader;
+ this.queue = new LinkedBlockingQueue<>(QUEUE_SIZE);
+ BraintrustShutdownHook.addShutdownHook(
+ BraintrustShutdownHook.ATTACHMENT_UPLOADER, this::shutdown);
+ }
+
+ @Override
+ public boolean enqueue(@Nonnull AttachmentReference reference, @Nonnull byte[] data) {
+ if (checkRejectNewJobsThreadSafe()) {
+ return false;
+ }
+ try {
+ ensureWorkerStarted();
+ UploadJob job = new UploadJob(reference, data);
+ queue.put(job);
+ return true;
+ } catch (Exception e) {
+ log.error("failed to enqueue attachment", e);
+ shutdown();
+ return false;
+ }
+ }
+
+ @Override
+ @SneakyThrows
+ public boolean forceFlush(@Nonnull Duration timeout) {
+ return awaitCurrentBatch(timeout.toMillis(), TimeUnit.MILLISECONDS);
+ }
+
+ @Override
+ @SneakyThrows
+ public void shutdown(@Nonnull Duration timeout) {
+ synchronized (lock) {
+ rejectNewJobs = true;
+ if (workerDone) {
+ return;
+ }
+ }
+ ExecutorService executor = worker.getAndSet(null);
+ if (executor == null) {
+ return;
+ }
+ executor.shutdown();
+ if (!executor.awaitTermination(timeout.toMillis(), TimeUnit.MILLISECONDS)) {
+ log.warn("failed to gracefully shut down s3 upload worker");
+ executor.shutdownNow();
+ }
+ }
+
+ @Override
+ public boolean isShutdown() {
+ return checkRejectNewJobsThreadSafe();
+ }
+
+ /**
+ * start worker thread or do nothing if already started
+ *
+ * calling this method does not require the lock
+ */
+ private void ensureWorkerStarted() {
+ if (worker.get() == null) {
+ var newWorker =
+ Executors.newSingleThreadExecutor(
+ r -> {
+ Thread t = new Thread(r, "braintrust-attachment-uploader");
+ t.setDaemon(true);
+ return t;
+ });
+ if (worker.compareAndSet(null, newWorker)) {
+ // NOTE: if shutdown is called concurrently job submission may throw an
+ // exception. This is fine.
+ newWorker.submit(this::workerLoop);
+ } else {
+ // tried to start the worker concurrently. This is fine, we'll just shut down
+ // and dereference the redundant worker
+ newWorker.shutdown();
+ }
+ }
+ }
+
+ private void workerLoop() {
+ log.debug("Attachment uploader worker started");
+ while ((!checkRejectNewJobsThreadSafe()) || queue.peek() != null) {
+ UploadJob job = null;
+ try {
+ job = queue.poll(100, TimeUnit.MILLISECONDS);
+ if (job == null) {
+ finishCurrentBatch();
+ } else {
+ upload(job);
+ }
+ } catch (InterruptedException e) {
+ // worker thread shutdownNow was invoked
+ if (!queue.isEmpty()) {
+ log.warn(
+ "s3 uploader force shutdown was reached. Dropping {} uploads",
+ queue.size(),
+ e);
+ }
+ break;
+ } catch (Exception e) {
+ // this only user of this util is our span processor so we'll just fall back to
+ // sending attachments in span data if an error occurs
+ synchronized (lock) {
+ rejectNewJobs = true;
+ }
+ if (job == null) {
+ log.warn("Failed to upload attachment", e);
+ } else {
+ log.warn("Failed to upload attachment key={}", job.reference().key(), e);
+ reportStatus(job.reference().key(), "error", e.getMessage());
+ }
+ // NOTE: we'll continue the loop attempting uploads of the remaining jobs until
+ // the queue is drained
+ }
+ }
+ synchronized (lock) {
+ workerDone = true;
+ finishCurrentBatch();
+ log.debug("Attachment uploader worker stopped");
+ }
+ }
+
+ private boolean checkRejectNewJobsThreadSafe() {
+ synchronized (lock) {
+ return rejectNewJobs;
+ }
+ }
+
+ private void upload(@Nonnull UploadJob job) throws IOException, InterruptedException {
+ S3Uploader.UploadUrlResponse urlResponse =
+ s3Uploader.requestUploadUrl(
+ getOrgId(),
+ job.reference().key(),
+ job.reference().filename(),
+ job.reference().contentType());
+
+ s3Uploader.uploadToSignedUrl(
+ urlResponse.signedUrl(),
+ urlResponse.headers(),
+ job.reference().contentType(),
+ job.data());
+
+ reportStatus(job.reference().key(), "done", null);
+ }
+
+ private String getOrgId() {
+ if (orgId.get() != null) {
+ return orgId.get();
+ }
+ return orgId.updateAndGet(curr -> curr != null ? curr : resolveOrgId());
+ }
+
+ private String resolveOrgId() {
+ try {
+ var loginResponse = s3Uploader.getApiClient().login();
+ if (loginResponse.orgInfo() != null && !loginResponse.orgInfo().isEmpty()) {
+ return loginResponse.orgInfo().get(0).id();
+ } else {
+ throw new IllegalStateException("No org info returned from login");
+ }
+ } catch (Exception e) {
+ throw new RuntimeException("Failed to resolve org ID for attachment upload", e);
+ }
+ }
+
+ private void reportStatus(
+ @Nonnull String key, @Nonnull String status, @Nullable String errorMessage) {
+ try {
+ var statusMap = new java.util.HashMap();
+ statusMap.put("upload_status", status);
+ if (errorMessage != null) {
+ statusMap.put("error_message", errorMessage);
+ }
+ s3Uploader.updateUploadStatus(getOrgId(), key, statusMap);
+ } catch (Exception e) {
+ log.warn("Failed to report attachment status key={} status={}", key, status, e);
+ }
+ }
+
+ private void finishCurrentBatch() {
+ synchronized (lock) {
+ currentBatch.countDown();
+ currentBatch = new CountDownLatch(1);
+ }
+ }
+
+ private boolean awaitCurrentBatch(long timeout, TimeUnit timeUnit)
+ throws InterruptedException {
+ CountDownLatch latch;
+ synchronized (lock) {
+ latch = currentBatch;
+ }
+ return latch.await(timeout, timeUnit);
+ }
+
+ private record UploadJob(AttachmentReference reference, byte[] data) {}
+ }
+}
diff --git a/braintrust-sdk/src/main/java/dev/braintrust/trace/BraintrustShutdownHook.java b/braintrust-sdk/src/main/java/dev/braintrust/trace/BraintrustShutdownHook.java
index a6f19910..823c2276 100644
--- a/braintrust-sdk/src/main/java/dev/braintrust/trace/BraintrustShutdownHook.java
+++ b/braintrust-sdk/src/main/java/dev/braintrust/trace/BraintrustShutdownHook.java
@@ -6,6 +6,9 @@
import java.util.concurrent.CopyOnWriteArrayList;
class BraintrustShutdownHook {
+ public static final int SPAN_PROCESSOR = 0;
+ public static final int ATTACHMENT_UPLOADER = SPAN_PROCESSOR + 1;
+
private record OrderedTarget(int order, Runnable target) {}
private static final List shutdownTargets = new CopyOnWriteArrayList<>();
@@ -22,9 +25,16 @@ private record OrderedTarget(int order, Runnable target) {}
}
public static void addShutdownHook(Runnable target) {
- addShutdownHook(0, target);
+ addShutdownHook(SPAN_PROCESSOR, target);
}
+ /**
+ * Add a jvm shutdown hook.
+ *
+ * @param order lower numbers run first. targets with the same order number can run in any
+ * order. Span processor/exporter flush runs at level 0
+ * @param target the shutdown code to run
+ */
public static void addShutdownHook(int order, Runnable target) {
shutdownTargets.add(new OrderedTarget(order, target));
}
diff --git a/braintrust-sdk/src/main/java/dev/braintrust/trace/BraintrustSpanProcessor.java b/braintrust-sdk/src/main/java/dev/braintrust/trace/BraintrustSpanProcessor.java
index 532193bd..a7755f2e 100644
--- a/braintrust-sdk/src/main/java/dev/braintrust/trace/BraintrustSpanProcessor.java
+++ b/braintrust-sdk/src/main/java/dev/braintrust/trace/BraintrustSpanProcessor.java
@@ -1,13 +1,19 @@
package dev.braintrust.trace;
+import dev.braintrust.api.BraintrustOpenApiClient;
import dev.braintrust.config.BraintrustConfig;
import io.opentelemetry.api.common.AttributeKey;
+import io.opentelemetry.api.common.Attributes;
import io.opentelemetry.context.Context;
import io.opentelemetry.sdk.common.CompletableResultCode;
+import io.opentelemetry.sdk.common.InstrumentationLibraryInfo;
import io.opentelemetry.sdk.trace.ReadWriteSpan;
import io.opentelemetry.sdk.trace.ReadableSpan;
import io.opentelemetry.sdk.trace.SpanProcessor;
+import io.opentelemetry.sdk.trace.data.DelegatingSpanData;
+import io.opentelemetry.sdk.trace.data.SpanData;
import java.util.List;
+import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
@@ -21,7 +27,10 @@
*/
@Slf4j
public class BraintrustSpanProcessor implements SpanProcessor {
- // Braintrust-specific attributes
+ static final AttributeKey INPUT_JSON = AttributeKey.stringKey("braintrust.input_json");
+ static final AttributeKey OUTPUT_JSON =
+ AttributeKey.stringKey("braintrust.output_json");
+
public static final AttributeKey PARENT =
AttributeKey.stringKey(BraintrustTracing.PARENT_KEY);
@@ -29,11 +38,16 @@ public class BraintrustSpanProcessor implements SpanProcessor {
private final SpanProcessor delegate;
private final List samplers;
private final ConcurrentMap parentContexts = new ConcurrentHashMap<>();
+ private final AttachmentProcessor attachmentProcessor;
BraintrustSpanProcessor(BraintrustConfig config, SpanProcessor delegate) {
this.config = config;
this.delegate = delegate;
this.samplers = buildSamplers(config);
+ this.attachmentProcessor =
+ new AttachmentProcessor(
+ new AttachmentUploader.S3AttachmentUploader(
+ new S3Uploader(BraintrustOpenApiClient.of(config))));
}
private static List buildSamplers(BraintrustConfig config) {
@@ -113,12 +127,25 @@ public void onEnd(ReadableSpan span) {
return;
}
}
- delegate.onEnd(span);
+
+ var spanData = span.toSpanData();
+ @Nullable String inputJson = spanData.getAttributes().get(INPUT_JSON);
+ @Nullable String outputJson = spanData.getAttributes().get(OUTPUT_JSON);
+
+ @Nullable String newInputJson = attachmentProcessor.processAndUpload(inputJson);
+ @Nullable String newOutputJson = attachmentProcessor.processAndUpload(outputJson);
+
+ if (!Objects.equals(newInputJson, inputJson)
+ || !Objects.equals(newOutputJson, outputJson)) {
+ delegate.onEnd(new TransformedReadableSpan(span, newInputJson, newOutputJson));
+ } else {
+ delegate.onEnd(span);
+ }
}
@Override
public boolean isEndRequired() {
- return !samplers.isEmpty() || delegate.isEndRequired();
+ return true;
}
@Override
@@ -170,4 +197,93 @@ public static ParentContext experiment(String experimentId) {
return new ParentContext(null, experimentId, ParentType.EXPERIMENT);
}
}
+
+ /**
+ * otel java does not implement onEnding, so this is the most idiomatic way to mutate a span
+ * once it ends
+ */
+ private static class TransformedReadableSpan implements ReadableSpan {
+ private final ReadableSpan delegate;
+ private final Attributes attributes;
+
+ TransformedReadableSpan(ReadableSpan delegate, String inputJson, String outputJson) {
+ this.delegate = delegate;
+ var builder = delegate.getAttributes().toBuilder();
+ builder.put(INPUT_JSON, inputJson);
+ builder.put(OUTPUT_JSON, outputJson);
+ attributes = builder.build();
+ }
+
+ @Override
+ public Attributes getAttributes() {
+ return attributes;
+ }
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public T getAttribute(AttributeKey key) {
+ if (key.equals(INPUT_JSON)) {
+ return (T) attributes.get(INPUT_JSON);
+ }
+ if (key.equals(OUTPUT_JSON)) {
+ return (T) attributes.get(OUTPUT_JSON);
+ }
+ return delegate.getAttribute(key);
+ }
+
+ @Override
+ public SpanData toSpanData() {
+ return new DelegatingSpanData(delegate.toSpanData()) {
+ @Override
+ public io.opentelemetry.api.common.Attributes getAttributes() {
+ return TransformedReadableSpan.this.getAttributes();
+ }
+
+ @Override
+ public int getTotalAttributeCount() {
+ return getAttributes().size();
+ }
+ };
+ }
+
+ @Override
+ public String getName() {
+ return delegate.getName();
+ }
+
+ @Override
+ public io.opentelemetry.api.trace.SpanContext getSpanContext() {
+ return delegate.getSpanContext();
+ }
+
+ @Override
+ public boolean hasEnded() {
+ return delegate.hasEnded();
+ }
+
+ @Override
+ public io.opentelemetry.sdk.common.InstrumentationScopeInfo getInstrumentationScopeInfo() {
+ return delegate.getInstrumentationScopeInfo();
+ }
+
+ @Override
+ public InstrumentationLibraryInfo getInstrumentationLibraryInfo() {
+ return delegate.getInstrumentationLibraryInfo();
+ }
+
+ @Override
+ public long getLatencyNanos() {
+ return delegate.getLatencyNanos();
+ }
+
+ @Override
+ public io.opentelemetry.api.trace.SpanContext getParentSpanContext() {
+ return delegate.getParentSpanContext();
+ }
+
+ @Override
+ public io.opentelemetry.api.trace.SpanKind getKind() {
+ return delegate.getKind();
+ }
+ }
}
diff --git a/braintrust-sdk/src/main/java/dev/braintrust/trace/S3Uploader.java b/braintrust-sdk/src/main/java/dev/braintrust/trace/S3Uploader.java
new file mode 100644
index 00000000..1fff7ff5
--- /dev/null
+++ b/braintrust-sdk/src/main/java/dev/braintrust/trace/S3Uploader.java
@@ -0,0 +1,326 @@
+package dev.braintrust.trace;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import dev.braintrust.api.BraintrustOpenApiClient;
+import dev.braintrust.json.BraintrustJsonMapper;
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.time.Duration;
+import java.util.Map;
+import javax.annotation.Nonnull;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+
+/** Uploads attachments to S3-compatible object storage via signed URLs. */
+@Slf4j
+class S3Uploader {
+ /** Default per-request timeout for HTTP calls. */
+ private static final Duration DEFAULT_REQUEST_TIMEOUT = Duration.ofSeconds(60);
+
+ /** Default maximum number of retry attempts for transient failures. */
+ private static final int DEFAULT_MAX_RETRIES = 8;
+
+ /** Default initial backoff delay between retries. Doubles on each subsequent attempt. */
+ private static final Duration DEFAULT_INITIAL_RETRY_DELAY = Duration.ofMillis(500);
+
+ private final BraintrustOpenApiClient apiClient;
+ private final Duration requestTimeout;
+ private final int maxRetries;
+ private final Duration initialRetryDelay;
+
+ /** Returns the API client used by this uploader. */
+ BraintrustOpenApiClient getApiClient() {
+ return apiClient;
+ }
+
+ /**
+ * Creates a new S3 uploader with default retry settings.
+ *
+ * @param apiClient the Braintrust API client (provides auth, base URL, and HTTP transport)
+ */
+ S3Uploader(@Nonnull BraintrustOpenApiClient apiClient) {
+ this(apiClient, DEFAULT_REQUEST_TIMEOUT, DEFAULT_MAX_RETRIES, DEFAULT_INITIAL_RETRY_DELAY);
+ }
+
+ /**
+ * Creates a new S3 uploader with custom retry settings.
+ *
+ * @param apiClient the Braintrust API client (provides auth, base URL, and HTTP transport)
+ * @param requestTimeout the per-request timeout for HTTP calls
+ * @param maxRetries the maximum number of retry attempts for transient failures
+ * @param initialRetryDelay the initial backoff delay between retries (doubles on each attempt)
+ */
+ S3Uploader(
+ @Nonnull BraintrustOpenApiClient apiClient,
+ @Nonnull Duration requestTimeout,
+ int maxRetries,
+ @Nonnull Duration initialRetryDelay) {
+ if (requestTimeout.toMillis() < 0) {
+ throw new IllegalArgumentException("requestTimeout must be >= 0");
+ }
+ if (maxRetries <= 0) {
+ throw new IllegalArgumentException("maxRetries must be > 0");
+ }
+ if (initialRetryDelay.toMillis() < 0) {
+ throw new IllegalArgumentException("initialRetryDelay must be >= 0");
+ }
+ this.apiClient = apiClient;
+ this.requestTimeout = requestTimeout;
+ this.maxRetries = maxRetries;
+ this.initialRetryDelay = initialRetryDelay;
+ }
+
+ /**
+ * Requests a signed upload URL from the Braintrust API.
+ *
+ * @param orgId the organization ID
+ * @param key the attachment key
+ * @param filename the filename for the attachment
+ * @param contentType the MIME type of the attachment
+ * @return the signed URL response with upload URL and required headers
+ * @throws IOException if the request fails
+ * @throws InterruptedException if the request is interrupted
+ */
+ UploadUrlResponse requestUploadUrl(
+ @Nonnull String orgId,
+ @Nonnull String key,
+ @Nonnull String filename,
+ @Nonnull String contentType)
+ throws IOException, InterruptedException {
+
+ var requestBody =
+ BraintrustJsonMapper.get()
+ .writeValueAsString(
+ new UploadUrlRequest(key, filename, contentType, orgId));
+
+ var requestBuilder =
+ HttpRequest.newBuilder()
+ .uri(toUri(apiClient.getBaseUri() + "/attachment"))
+ .timeout(requestTimeout)
+ .header("Content-Type", "application/json")
+ .header("Accept", "application/json")
+ .POST(HttpRequest.BodyPublishers.ofString(requestBody));
+
+ if (apiClient.getRequestInterceptor() != null) {
+ apiClient.getRequestInterceptor().accept(requestBuilder);
+ }
+
+ HttpResponse response =
+ sendWithRetry(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
+
+ if (!isSuccessStatus(response.statusCode())) {
+ throw new IOException(
+ "Failed to request upload URL: HTTP "
+ + response.statusCode()
+ + " - "
+ + response.body());
+ }
+
+ UploadUrlResponse result =
+ BraintrustJsonMapper.get().readValue(response.body(), UploadUrlResponse.class);
+
+ if (result.signedUrl() == null || result.signedUrl().isEmpty()) {
+ throw new IOException("Signed URL response missing signedUrl");
+ }
+
+ return result;
+ }
+
+ /**
+ * Uploads data to a signed URL with the specified headers.
+ *
+ * Automatically detects Azure Blob Storage URLs and adds the required {@code x-ms-blob-type:
+ * BlockBlob} header.
+ *
+ * @param signedUrl the signed upload URL
+ * @param headers additional headers to include in the upload request
+ * @param contentType the MIME type of the data being uploaded
+ * @param data the data to upload
+ * @throws IOException if the upload fails
+ * @throws InterruptedException if the upload is interrupted
+ */
+ void uploadToSignedUrl(
+ @Nonnull String signedUrl,
+ @Nonnull Map headers,
+ @Nonnull String contentType,
+ @Nonnull byte[] data)
+ throws IOException, InterruptedException {
+
+ var requestBuilder =
+ HttpRequest.newBuilder()
+ .uri(toUri(signedUrl))
+ .timeout(requestTimeout)
+ .header("Content-Type", contentType)
+ .PUT(HttpRequest.BodyPublishers.ofByteArray(data));
+
+ for (var entry : headers.entrySet()) {
+ requestBuilder.header(entry.getKey(), entry.getValue());
+ }
+
+ addAzureBlobHeaders(signedUrl, requestBuilder);
+
+ HttpResponse response =
+ sendWithRetry(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
+
+ if (!isSuccessStatus(response.statusCode())) {
+ throw new IOException(
+ "Failed to upload to object store: HTTP "
+ + response.statusCode()
+ + " - "
+ + response.body());
+ }
+ }
+
+ /**
+ * Updates the upload status for an attachment.
+ *
+ * @param orgId the organization ID
+ * @param key the attachment key
+ * @param status the status map (e.g., {"upload_status": "done"} or {"upload_status": "error",
+ * "error_message": "..."})
+ * @throws IOException if the request fails
+ * @throws InterruptedException if the request is interrupted
+ */
+ void updateUploadStatus(
+ @Nonnull String orgId, @Nonnull String key, @Nonnull Map status)
+ throws IOException, InterruptedException {
+
+ var requestBody =
+ BraintrustJsonMapper.get()
+ .writeValueAsString(new StatusRequest(key, orgId, status));
+
+ var requestBuilder =
+ HttpRequest.newBuilder()
+ .uri(toUri(apiClient.getBaseUri() + "/attachment/status"))
+ .timeout(requestTimeout)
+ .header("Content-Type", "application/json")
+ .POST(HttpRequest.BodyPublishers.ofString(requestBody));
+
+ if (apiClient.getRequestInterceptor() != null) {
+ apiClient.getRequestInterceptor().accept(requestBuilder);
+ }
+
+ HttpResponse response =
+ sendWithRetry(requestBuilder.build(), HttpResponse.BodyHandlers.ofString());
+
+ if (!isSuccessStatus(response.statusCode())) {
+ throw new IOException(
+ "Failed to update upload status: HTTP "
+ + response.statusCode()
+ + " - "
+ + response.body());
+ }
+ }
+
+ /** Returns {@code true} if the HTTP status code indicates success (2xx). */
+ private static boolean isSuccessStatus(int statusCode) {
+ return statusCode >= 200 && statusCode < 300;
+ }
+
+ /**
+ * Parses a URI string.
+ *
+ * @param uriString the string to parse
+ * @return the parsed URI
+ */
+ @SneakyThrows
+ private static URI toUri(@Nonnull String uriString) {
+ return new URI(uriString);
+ }
+
+ /**
+ * Sends an HTTP request with retry logic for transient failures.
+ *
+ * Retries on 5xx server errors and {@link IOException} (network errors) up to {@link
+ * #maxRetries} times with exponential backoff starting at {@link #initialRetryDelay}.
+ *
+ * @param request the request to send
+ * @param bodyHandler the response body handler
+ * @param the response body type
+ * @return the HTTP response
+ * @throws IOException if all retries are exhausted
+ * @throws InterruptedException if the thread is interrupted during retry backoff
+ */
+ private HttpResponse sendWithRetry(
+ @Nonnull HttpRequest request, @Nonnull HttpResponse.BodyHandler bodyHandler)
+ throws IOException, InterruptedException {
+
+ IOException lastException = null;
+ long backoffMs = initialRetryDelay.toMillis();
+
+ for (int attempt = 0; attempt <= maxRetries; attempt++) {
+ if (attempt > 0) {
+ log.debug(
+ "Retrying request {} (attempt {}/{})", request.uri(), attempt, maxRetries);
+ Thread.sleep(backoffMs);
+ backoffMs *= 2;
+ }
+
+ HttpResponse response;
+ try {
+ response = apiClient.getHttpClient().send(request, bodyHandler);
+ } catch (IOException e) {
+ lastException = e;
+ log.debug("Request to {} failed with IOException", request.uri(), e);
+ continue;
+ }
+
+ // Don't retry client errors (4xx) or successes
+ if (response.statusCode() < 500) {
+ return response;
+ }
+
+ // Server error (5xx) — retry
+ lastException = new IOException("Server error: HTTP " + response.statusCode());
+ log.debug(
+ "Request to {} returned status {}, will retry",
+ request.uri(),
+ response.statusCode());
+ }
+
+ throw new IOException(
+ "Request to " + request.uri() + " failed after " + maxRetries + " retries",
+ lastException);
+ }
+
+ /** Adds Azure Blob Storage specific headers when the signed URL points to Azure. */
+ private static void addAzureBlobHeaders(
+ @Nonnull String signedUrl, HttpRequest.Builder requestBuilder) {
+ try {
+ var uri = new URI(signedUrl);
+ String host = uri.getHost();
+ if (host != null && host.endsWith(".blob.core.windows.net")) {
+ requestBuilder.header("x-ms-blob-type", "BlockBlob");
+ }
+ } catch (URISyntaxException e) {
+ log.warn("Failed to parse signed URL for Azure detection: {}", signedUrl, e);
+ }
+ }
+
+ /** Response from requesting a signed upload URL. */
+ record UploadUrlResponse(
+ @JsonProperty("signedUrl") @Nonnull String signedUrl,
+ @JsonProperty("headers") @Nonnull Map headers) {
+
+ /** Compact constructor that enforces non-null headers with an empty map default. */
+ UploadUrlResponse {
+ if (headers == null) {
+ headers = Map.of();
+ }
+ }
+ }
+
+ private record UploadUrlRequest(
+ @Nonnull String key,
+ @Nonnull String filename,
+ @JsonProperty("content_type") @Nonnull String contentType,
+ @JsonProperty("org_id") @Nonnull String orgId) {}
+
+ private record StatusRequest(
+ @Nonnull String key,
+ @JsonProperty("org_id") @Nonnull String orgId,
+ @Nonnull Map status) {}
+}
diff --git a/braintrust-sdk/src/test/java/dev/braintrust/BraintrustTest.java b/braintrust-sdk/src/test/java/dev/braintrust/BraintrustTest.java
index c9074bbe..75f8a96c 100644
--- a/braintrust-sdk/src/test/java/dev/braintrust/BraintrustTest.java
+++ b/braintrust-sdk/src/test/java/dev/braintrust/BraintrustTest.java
@@ -7,6 +7,7 @@
import java.net.URI;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
public class BraintrustTest {
@@ -166,6 +167,7 @@ void testGetReturnsSameInstanceAfterInitialization() {
}
@Test
+ @Disabled // TOOD: need to re-record cassettes
public void testProjectURI() {
var harness = TestHarness.setup();
var config = harness.braintrust().config();
diff --git a/braintrust-sdk/src/test/java/dev/braintrust/trace/AttachmentProcessorTest.java b/braintrust-sdk/src/test/java/dev/braintrust/trace/AttachmentProcessorTest.java
new file mode 100644
index 00000000..ae0870b9
--- /dev/null
+++ b/braintrust-sdk/src/test/java/dev/braintrust/trace/AttachmentProcessorTest.java
@@ -0,0 +1,85 @@
+package dev.braintrust.trace;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import dev.braintrust.json.BraintrustJsonMapper;
+import java.time.Duration;
+import org.jspecify.annotations.NonNull;
+import org.junit.jupiter.api.Test;
+
+public class AttachmentProcessorTest {
+ private final AttachmentProcessor attachmentProcessor =
+ new AttachmentProcessor(new NoOpAttachmentUploader());
+
+ @Test
+ void replacesEntireDataUriWithObjectNode() throws Exception {
+ String json =
+ """
+ [{"role":"user","content":[{"type":"text","text":"hi"},{"type":"image_url","image_url":{"url":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg=="}}]}]
+ """;
+ String newJson = attachmentProcessor.processAndUpload(json);
+ assertNotEquals(json, newJson);
+
+ JsonNode root = BraintrustJsonMapper.get().readTree(json);
+ {
+ JsonNode urlNode = root.get(0).get("content").get(1).get("image_url").get("url");
+ assertTrue(urlNode.isTextual(), "original url should be a text node");
+ }
+
+ JsonNode newRoot = BraintrustJsonMapper.get().readTree(newJson);
+ {
+ JsonNode newUrlNode = newRoot.get(0).get("content").get(1).get("image_url").get("url");
+ // Verify newUrl is a valid braintrust attachment object
+ assertTrue(newUrlNode.isObject(), "replaced url should be an object node");
+ assertEquals("braintrust_attachment", newUrlNode.get("type").asText());
+ assertEquals("image/png", newUrlNode.get("content_type").asText());
+ assertEquals("attachment.png", newUrlNode.get("filename").asText());
+ assertNotNull(newUrlNode.get("key"), "attachment key must be present");
+ assertFalse(
+ newUrlNode.get("key").asText().isEmpty(), "attachment key must not be empty");
+ }
+
+ // Verify only image_url.url was mutated: removing the url field from both should yield
+ // identical JSON
+ ((ObjectNode) root.get(0).get("content").get(1).get("image_url")).remove("url");
+ ((ObjectNode) newRoot.get(0).get("content").get(1).get("image_url")).remove("url");
+ assertEquals(
+ BraintrustJsonMapper.get().writeValueAsString(root),
+ BraintrustJsonMapper.get().writeValueAsString(newRoot),
+ "only the url field should differ between original and processed JSON");
+ }
+
+ @Test
+ void doesNotReplacePartialDataUri() {
+ String json =
+ """
+ {"text":"hello data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg== world"}
+ """;
+ // processAndUpload should leave the JSON unchanged end-to-end
+ String newJson = attachmentProcessor.processAndUpload(json);
+ assertEquals(json, newJson, "partial data URI in text should not be replaced");
+ }
+
+ private static class NoOpAttachmentUploader implements AttachmentUploader {
+ @Override
+ public boolean enqueue(
+ @NonNull AttachmentReference reference, @NonNull byte @NonNull [] data) {
+ return true;
+ }
+
+ @Override
+ public boolean forceFlush(@NonNull Duration timeout) {
+ return true;
+ }
+
+ @Override
+ public void shutdown(@NonNull Duration timeout) {}
+
+ @Override
+ public boolean isShutdown() {
+ return false;
+ }
+ }
+}
diff --git a/braintrust-sdk/src/test/java/dev/braintrust/trace/AttachmentReferenceTest.java b/braintrust-sdk/src/test/java/dev/braintrust/trace/AttachmentReferenceTest.java
new file mode 100644
index 00000000..e73450d6
--- /dev/null
+++ b/braintrust-sdk/src/test/java/dev/braintrust/trace/AttachmentReferenceTest.java
@@ -0,0 +1,46 @@
+package dev.braintrust.trace;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.UUID;
+import org.junit.jupiter.api.Test;
+
+public class AttachmentReferenceTest {
+
+ @Test
+ void createGeneratesUniqueKeys() {
+ var ref1 = AttachmentReference.create("test.json", "application/json");
+ var ref2 = AttachmentReference.create("test.json", "application/json");
+
+ assertEquals("braintrust_attachment", ref1.type());
+ assertEquals("test.json", ref1.filename());
+ assertEquals("application/json", ref1.contentType());
+ assertNotNull(ref1.key());
+
+ assertNotEquals(ref1.key(), ref2.key());
+ }
+
+ @Test
+ void createValidatesFilename() {
+ assertThrows(
+ NullPointerException.class,
+ () -> AttachmentReference.create(null, "application/json"));
+ }
+
+ @Test
+ void createValidatesContentType() {
+ assertThrows(
+ NullPointerException.class, () -> AttachmentReference.create("test.json", null));
+ }
+
+ @Test
+ void recordComponentsAccessible() {
+ String customKey = UUID.randomUUID().toString();
+ var ref = new AttachmentReference("custom_type", "data.xml", "application/xml", customKey);
+
+ assertEquals("custom_type", ref.type());
+ assertEquals("data.xml", ref.filename());
+ assertEquals("application/xml", ref.contentType());
+ assertEquals(customKey, ref.key());
+ }
+}
diff --git a/braintrust-sdk/src/test/java/dev/braintrust/trace/AttachmentUploaderTest.java b/braintrust-sdk/src/test/java/dev/braintrust/trace/AttachmentUploaderTest.java
new file mode 100644
index 00000000..6cc5cbcc
--- /dev/null
+++ b/braintrust-sdk/src/test/java/dev/braintrust/trace/AttachmentUploaderTest.java
@@ -0,0 +1,189 @@
+package dev.braintrust.trace;
+
+import static com.github.tomakehurst.wiremock.client.WireMock.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+import com.github.tomakehurst.wiremock.junit5.WireMockRuntimeInfo;
+import com.github.tomakehurst.wiremock.junit5.WireMockTest;
+import dev.braintrust.api.BraintrustOpenApiClient;
+import dev.braintrust.config.BraintrustConfig;
+import java.time.Duration;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+@WireMockTest
+public class AttachmentUploaderTest {
+ private AttachmentUploader.S3AttachmentUploader uploader;
+ private String baseUrl;
+
+ @BeforeEach
+ void setUp(WireMockRuntimeInfo wmRuntimeInfo) {
+ baseUrl = wmRuntimeInfo.getHttpBaseUrl();
+ var config = BraintrustConfig.builder().apiKey("test-api-key").apiUrl(baseUrl).build();
+ var apiClient = BraintrustOpenApiClient.of(config);
+ uploader =
+ new AttachmentUploader.S3AttachmentUploader(
+ new S3Uploader(
+ apiClient, Duration.ofMillis(10_000), 1, Duration.ofMillis(50)));
+ }
+
+ @AfterEach
+ void tearDown() {
+ uploader.shutdown(Duration.ofSeconds(0));
+ }
+
+ private void stubLoginAndUploadFlow() {
+ stubFor(
+ post(urlEqualTo("/api/apikey/login"))
+ .willReturn(
+ aResponse()
+ .withStatus(200)
+ .withHeader("Content-Type", "application/json")
+ .withBody(
+ "{\"org_info\":[{\"id\":\"org-123\",\"name\":\"test-org\"}]}")));
+
+ stubFor(
+ post(urlEqualTo("/attachment"))
+ .willReturn(
+ aResponse()
+ .withStatus(200)
+ .withHeader("Content-Type", "application/json")
+ .withBody(
+ "{\"signedUrl\":\""
+ + baseUrl
+ + "/upload\",\"headers\":{}}")));
+
+ stubFor(put(urlEqualTo("/upload")).willReturn(aResponse().withStatus(200)));
+
+ stubFor(post(urlEqualTo("/attachment/status")).willReturn(aResponse().withStatus(200)));
+ }
+
+ @Test
+ void enqueueUploadsSuccessfully() throws Exception {
+ stubLoginAndUploadFlow();
+
+ var ref = AttachmentReference.create("test.json", "application/json");
+ uploader.enqueue(ref, "{\"key\":\"value\"}".getBytes());
+ uploader.forceFlush();
+
+ verify(
+ postRequestedFor(urlEqualTo("/attachment"))
+ .withRequestBody(containing("\"key\":\"" + ref.key() + "\"")));
+ verify(putRequestedFor(urlEqualTo("/upload")));
+ verify(
+ postRequestedFor(urlEqualTo("/attachment/status"))
+ .withRequestBody(containing("\"upload_status\":\"done\"")));
+ }
+
+ @Test
+ void enqueueRejectsAfterShutdown() {
+ assertDoesNotThrow(() -> uploader.shutdown());
+
+ var ref = AttachmentReference.create("test.json", "application/json");
+ assertFalse(uploader.enqueue(ref, "data".getBytes()));
+ }
+
+ @Test
+ void forceFlushWaitsForPendingUploads() throws Exception {
+ stubLoginAndUploadFlow();
+
+ var ref = AttachmentReference.create("test.json", "application/json");
+ uploader.enqueue(ref, "data".getBytes());
+
+ AtomicBoolean flushed = new AtomicBoolean(false);
+ var flushThread =
+ new Thread(
+ () -> {
+ uploader.forceFlush();
+ flushed.set(true);
+ });
+ flushThread.start();
+
+ flushThread.join(5000);
+ assertTrue(flushed.get(), "forceFlush should complete after upload finishes");
+ assertFalse(flushThread.isAlive());
+ }
+
+ @Test
+ void shutdownWaitsForPendingUploads() throws Exception {
+ stubLoginAndUploadFlow();
+
+ var ref = AttachmentReference.create("test.json", "application/json");
+ uploader.enqueue(ref, "data".getBytes());
+
+ uploader.shutdown(Duration.ofSeconds(5));
+
+ verify(
+ postRequestedFor(urlEqualTo("/attachment/status"))
+ .withRequestBody(containing("\"upload_status\":\"done\"")));
+ }
+
+ @Test
+ void uploadFailureShutsDownWorker() throws Exception {
+ stubFor(
+ post(urlEqualTo("/api/apikey/login"))
+ .willReturn(
+ aResponse()
+ .withStatus(200)
+ .withHeader("Content-Type", "application/json")
+ .withBody(
+ "{\"org_info\":[{\"id\":\"org-123\",\"name\":\"test-org\"}]}")));
+
+ stubFor(
+ post(urlEqualTo("/attachment"))
+ .willReturn(
+ aResponse()
+ .withStatus(200)
+ .withHeader("Content-Type", "application/json")
+ .withBody(
+ "{\"signedUrl\":\""
+ + baseUrl
+ + "/upload\",\"headers\":{}}")));
+
+ stubFor(
+ put(urlEqualTo("/upload"))
+ .willReturn(aResponse().withStatus(500).withBody("Failed")));
+
+ stubFor(post(urlEqualTo("/attachment/status")).willReturn(aResponse().withStatus(200)));
+
+ var ref = AttachmentReference.create("test.json", "application/json");
+ assertTrue(uploader.enqueue(ref, "data".getBytes()));
+ // even errors should notify completion
+ uploader.forceFlush(Duration.ofSeconds(5));
+ assertFalse(uploader.enqueue(ref, "data".getBytes()));
+
+ verify(
+ postRequestedFor(urlEqualTo("/attachment/status"))
+ .withRequestBody(containing("\"upload_status\":\"error\""))
+ .withRequestBody(containing("\"error_message\"")));
+ }
+
+ @Test
+ void multipleUploadsProcessedSequentially() throws Exception {
+ stubLoginAndUploadFlow();
+
+ var ref1 = AttachmentReference.create("test1.json", "application/json");
+ var ref2 = AttachmentReference.create("test2.json", "application/json");
+
+ uploader.enqueue(ref1, "data1".getBytes());
+ uploader.enqueue(ref2, "data2".getBytes());
+ uploader.forceFlush();
+
+ verify(2, postRequestedFor(urlEqualTo("/attachment")));
+ verify(2, putRequestedFor(urlEqualTo("/upload")));
+ verify(2, postRequestedFor(urlEqualTo("/attachment/status")));
+ }
+
+ @Test
+ void lazyWorkerStartsOnFirstEnqueue() throws Exception {
+ stubLoginAndUploadFlow();
+
+ var ref = AttachmentReference.create("test.json", "application/json");
+ uploader.enqueue(ref, "data".getBytes());
+ uploader.forceFlush();
+
+ verify(postRequestedFor(urlEqualTo("/attachment")));
+ }
+}
diff --git a/braintrust-sdk/src/test/java/dev/braintrust/trace/S3UploaderTest.java b/braintrust-sdk/src/test/java/dev/braintrust/trace/S3UploaderTest.java
new file mode 100644
index 00000000..01745074
--- /dev/null
+++ b/braintrust-sdk/src/test/java/dev/braintrust/trace/S3UploaderTest.java
@@ -0,0 +1,255 @@
+package dev.braintrust.trace;
+
+import static com.github.tomakehurst.wiremock.client.WireMock.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+import com.github.tomakehurst.wiremock.junit5.WireMockRuntimeInfo;
+import com.github.tomakehurst.wiremock.junit5.WireMockTest;
+import dev.braintrust.api.BraintrustOpenApiClient;
+import dev.braintrust.config.BraintrustConfig;
+import java.time.Duration;
+import java.util.Map;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+@WireMockTest
+public class S3UploaderTest {
+
+ private S3Uploader uploader;
+ private String baseUrl;
+
+ @BeforeEach
+ void setUp(WireMockRuntimeInfo wmRuntimeInfo) {
+ baseUrl = wmRuntimeInfo.getHttpBaseUrl();
+ var config = BraintrustConfig.builder().apiKey("test-api-key").apiUrl(baseUrl).build();
+ var apiClient = BraintrustOpenApiClient.of(config);
+ // Use minimal retries and backoff so error tests complete quickly
+ uploader = new S3Uploader(apiClient, Duration.ofSeconds(10), 1, Duration.ofMillis(50));
+ }
+
+ @Test
+ void requestUploadUrlSendsCorrectRequest() throws Exception {
+ stubFor(
+ post(urlEqualTo("/attachment"))
+ .withHeader("Authorization", equalTo("Bearer test-api-key"))
+ .withHeader("Content-Type", equalTo("application/json"))
+ .willReturn(
+ aResponse()
+ .withStatus(200)
+ .withHeader("Content-Type", "application/json")
+ .withBody(
+ "{\"signedUrl\":\""
+ + baseUrl
+ + "/upload\",\"headers\":{\"X-Custom\":\"value\"}}")));
+
+ var response =
+ uploader.requestUploadUrl("org-123", "key-1", "test.json", "application/json");
+
+ assertEquals(baseUrl + "/upload", response.signedUrl());
+ assertEquals("value", response.headers().get("X-Custom"));
+
+ var requests = findAll(postRequestedFor(urlEqualTo("/attachment")));
+ assertEquals(1, requests.size());
+ }
+
+ @Test
+ void requestUploadUrlThrowsOnMissingSignedUrl() {
+ stubFor(
+ post(urlEqualTo("/attachment"))
+ .willReturn(aResponse().withStatus(200).withBody("{\"headers\":{}}")));
+
+ assertThrows(
+ java.io.IOException.class,
+ () ->
+ uploader.requestUploadUrl(
+ "org-123", "key-1", "test.json", "application/json"));
+ }
+
+ @Test
+ void requestUploadUrlThrowsOnApiError() {
+ stubFor(
+ post(urlEqualTo("/attachment"))
+ .willReturn(aResponse().withStatus(500).withBody("Internal error")));
+
+ assertThrows(
+ java.io.IOException.class,
+ () ->
+ uploader.requestUploadUrl(
+ "org-123", "key-1", "test.json", "application/json"));
+ }
+
+ @Test
+ void uploadToSignedUrlSendsPutRequest() throws Exception {
+ byte[] testData = "{\"hello\":\"world\"}".getBytes();
+
+ stubFor(
+ put(urlEqualTo("/upload"))
+ .withRequestBody(equalToJson("{\"hello\":\"world\"}"))
+ .willReturn(aResponse().withStatus(200)));
+
+ uploader.uploadToSignedUrl(baseUrl + "/upload", Map.of(), "application/json", testData);
+
+ verify(
+ putRequestedFor(urlEqualTo("/upload"))
+ .withHeader("Content-Type", equalTo("application/json")));
+ }
+
+ @Test
+ void uploadToSignedUrlIncludesHeaders() throws Exception {
+ byte[] testData = "test data".getBytes();
+
+ stubFor(
+ put(urlEqualTo("/upload"))
+ .withHeader("X-Custom-Header", equalTo("custom-value"))
+ .willReturn(aResponse().withStatus(200)));
+
+ uploader.uploadToSignedUrl(
+ baseUrl + "/upload",
+ Map.of("X-Custom-Header", "custom-value"),
+ "application/octet-stream",
+ testData);
+ }
+
+ @Test
+ void uploadToSignedUrlThrowsOnUploadError() {
+ byte[] testData = "test data".getBytes();
+
+ stubFor(
+ put(urlEqualTo("/upload"))
+ .willReturn(aResponse().withStatus(500).withBody("Upload failed")));
+
+ assertThrows(
+ java.io.IOException.class,
+ () ->
+ uploader.uploadToSignedUrl(
+ baseUrl + "/upload",
+ Map.of(),
+ "application/octet-stream",
+ testData));
+ }
+
+ @Test
+ void updateUploadStatusSendsCorrectRequest() throws Exception {
+ stubFor(
+ post(urlEqualTo("/attachment/status"))
+ .withHeader("Authorization", equalTo("Bearer test-api-key"))
+ .withHeader("Content-Type", equalTo("application/json"))
+ .willReturn(aResponse().withStatus(200)));
+
+ uploader.updateUploadStatus("org-123", "key-1", Map.of("upload_status", "done"));
+
+ verify(
+ postRequestedFor(urlEqualTo("/attachment/status"))
+ .withRequestBody(containing("\"key\":\"key-1\""))
+ .withRequestBody(containing("\"org_id\":\"org-123\""))
+ .withRequestBody(containing("\"upload_status\":\"done\"")));
+ }
+
+ @Test
+ void updateUploadStatusIncludesErrorMessage() throws Exception {
+ stubFor(post(urlEqualTo("/attachment/status")).willReturn(aResponse().withStatus(200)));
+
+ uploader.updateUploadStatus(
+ "org-123",
+ "key-1",
+ Map.of("upload_status", "error", "error_message", "something went wrong"));
+
+ verify(
+ postRequestedFor(urlEqualTo("/attachment/status"))
+ .withRequestBody(containing("\"error_message\":\"something went wrong\"")));
+ }
+
+ @Test
+ void updateUploadStatusThrowsOnApiError() {
+ stubFor(
+ post(urlEqualTo("/attachment/status"))
+ .willReturn(aResponse().withStatus(500).withBody("Error")));
+
+ assertThrows(
+ java.io.IOException.class,
+ () ->
+ uploader.updateUploadStatus(
+ "org-123", "key-1", Map.of("upload_status", "done")));
+ }
+
+ @Test
+ void uploadToAzureBlobAddsRequiredHeader() throws Exception {
+ byte[] testData = "azure test".getBytes();
+
+ stubFor(put(urlEqualTo("/non-azure-upload")).willReturn(aResponse().withStatus(200)));
+
+ uploader.uploadToSignedUrl(
+ baseUrl + "/non-azure-upload", Map.of(), "application/octet-stream", testData);
+
+ // Non-Azure URL should NOT have the x-ms-blob-type header
+ verify(putRequestedFor(urlEqualTo("/non-azure-upload")).withoutHeader("x-ms-blob-type"));
+ }
+
+ @Test
+ void uploadUrlResponseDefaultsNullHeadersToEmptyMap() {
+ var response = new S3Uploader.UploadUrlResponse("https://example.com/upload", null);
+
+ assertNotNull(response.headers());
+ assertTrue(response.headers().isEmpty());
+ }
+
+ @Test
+ void requestUploadUrlDefaultsNullHeadersToEmptyMap() throws Exception {
+ stubFor(
+ post(urlEqualTo("/attachment"))
+ .willReturn(
+ aResponse()
+ .withStatus(200)
+ .withHeader("Content-Type", "application/json")
+ .withBody("{\"signedUrl\":\"" + baseUrl + "/upload\"}")));
+
+ var response =
+ uploader.requestUploadUrl("org-123", "key-1", "test.json", "application/json");
+
+ assertNotNull(response.headers());
+ assertTrue(response.headers().isEmpty());
+ }
+
+ @Test
+ void customRetrySettingsAreUsed() throws Exception {
+ var config = BraintrustConfig.builder().apiKey("test-api-key").apiUrl(baseUrl).build();
+ var apiClient = BraintrustOpenApiClient.of(config);
+ var customUploader =
+ new S3Uploader(apiClient, Duration.ofSeconds(30), 2, Duration.ofMillis(100));
+
+ // First two requests fail with 500, third succeeds
+ stubFor(
+ post(urlEqualTo("/attachment"))
+ .inScenario("retry-test")
+ .whenScenarioStateIs("Started")
+ .willReturn(aResponse().withStatus(500).withBody("Error"))
+ .willSetStateTo("retry-1"));
+
+ stubFor(
+ post(urlEqualTo("/attachment"))
+ .inScenario("retry-test")
+ .whenScenarioStateIs("retry-1")
+ .willReturn(aResponse().withStatus(500).withBody("Error"))
+ .willSetStateTo("retry-2"));
+
+ stubFor(
+ post(urlEqualTo("/attachment"))
+ .inScenario("retry-test")
+ .whenScenarioStateIs("retry-2")
+ .willReturn(
+ aResponse()
+ .withStatus(200)
+ .withHeader("Content-Type", "application/json")
+ .withBody(
+ "{\"signedUrl\":\""
+ + baseUrl
+ + "/upload\",\"headers\":{}}")));
+
+ var response =
+ customUploader.requestUploadUrl(
+ "org-123", "key-1", "test.json", "application/json");
+
+ assertEquals(baseUrl + "/upload", response.signedUrl());
+ verify(3, postRequestedFor(urlEqualTo("/attachment")));
+ }
+}
diff --git a/test-harness/build.gradle b/test-harness/build.gradle
index 9cbf0a74..bd5df12f 100644
--- a/test-harness/build.gradle
+++ b/test-harness/build.gradle
@@ -23,7 +23,8 @@ ext {
dependencies {
// testFixtures dependencies — everything lives in testFixtures source set
- testFixturesImplementation project(":braintrust-sdk") // SDK main source (for TestHarness -> Braintrust, BraintrustConfig)
+ testFixturesImplementation project(":braintrust-api")
+ testFixturesImplementation project(":braintrust-sdk")
testFixturesImplementation project(":braintrust-java-agent:internal")
testFixturesImplementation project(":braintrust-java-agent:bootstrap")
testFixturesImplementation project(":braintrust-java-agent:instrumenter")
diff --git a/test-harness/src/testFixtures/java/dev/braintrust/TestHarness.java b/test-harness/src/testFixtures/java/dev/braintrust/TestHarness.java
index d16e1279..98bf9945 100644
--- a/test-harness/src/testFixtures/java/dev/braintrust/TestHarness.java
+++ b/test-harness/src/testFixtures/java/dev/braintrust/TestHarness.java
@@ -2,6 +2,7 @@
import static org.junit.jupiter.api.Assertions.assertTrue;
+import dev.braintrust.api.BraintrustOpenApiClient;
import dev.braintrust.config.BraintrustConfig;
import dev.braintrust.trace.UnitTestShutdownHook;
import io.opentelemetry.api.GlobalOpenTelemetry;
@@ -16,6 +17,7 @@
import io.opentelemetry.sdk.trace.data.SpanData;
import io.opentelemetry.sdk.trace.export.SimpleSpanProcessor;
import java.util.List;
+import java.util.Objects;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Function;
@@ -26,6 +28,26 @@
public class TestHarness {
private static final VCR vcr;
+ private static final BraintrustConfig envConfig =
+ BraintrustConfig.builder().defaultProjectName("java-unit-test").build();
+
+ @Getter
+ @Accessors(fluent = true)
+ private static final String defaultOrgName;
+
+ @Getter
+ @Accessors(fluent = true)
+ private static final String defaultProjectName;
+
+ @Getter
+ @Accessors(fluent = true)
+ private static final String defaultOrgId;
+
+ @Getter
+ @Accessors(fluent = true)
+ private static final String defaultProjectId;
+
+ private static final AtomicReference INSTANCE = new AtomicReference<>();
static {
// Collect all API keys that should never appear in recorded cassettes
@@ -42,14 +64,34 @@ public class TestHarness {
vcr =
new VCR(
java.util.Map.of(
- "https://api.openai.com/v1", "openai",
- "https://api.anthropic.com", "anthropic",
- "https://generativelanguage.googleapis.com", "google",
- "https://api.braintrust.dev", "braintrust",
- "https://bedrock-runtime.us-east-1.amazonaws.com", "bedrock"),
+ "https://api.openai.com/v1",
+ "openai",
+ "https://api.anthropic.com",
+ "anthropic",
+ "https://generativelanguage.googleapis.com",
+ "google",
+ envConfig.apiUrl(),
+ "braintrust",
+ "https://bedrock-runtime.us-east-1.amazonaws.com",
+ "bedrock"),
apiKeysToNeverRecord);
vcr.start();
UnitTestShutdownHook.addShutdownHook(1, vcr::stop);
+ var client = BraintrustOpenApiClient.of(envConfig);
+ var project = client.fetchOrCreateProject(envConfig);
+ defaultOrgId = project.getOrgId().toString();
+ defaultProjectId = project.getId().toString();
+ defaultProjectName = project.getName();
+ var orgs = client.login().orgInfo();
+ BraintrustOpenApiClient.OrgInfo defaultOrg = null;
+ for (var org : orgs) {
+ if (org.id().equals(defaultOrgId)) {
+ defaultOrg = org;
+ break;
+ }
+ }
+ Objects.requireNonNull(defaultOrg);
+ defaultOrgName = defaultOrg.name();
}
public static TestHarness setup() {
@@ -60,7 +102,7 @@ public static TestHarness setup(
Function configCustomizer) {
var configBuilder =
BraintrustConfig.builder()
- .apiUrl(vcr.getUrlForTargetBase("https://api.braintrust.dev"))
+ .apiUrl(vcr.getUrlForTargetBase(envConfig.apiUrl()))
.defaultProjectName(defaultProjectName());
if (vcr.getMode() == VCR.VcrMode.REPLAY) {
// tolerate missing api key in replay mode
@@ -84,24 +126,6 @@ private static synchronized TestHarness setup(BraintrustConfig config) {
return harness;
}
- @Getter
- @Accessors(fluent = true)
- private static final String defaultProjectId = "6ae68365-7620-4630-921b-bac416634fc8";
-
- @Getter
- @Accessors(fluent = true)
- private static final String defaultProjectName = "java-unit-test";
-
- @Getter
- @Accessors(fluent = true)
- private static final String defaultOrgId = "5d7c97d7-fef1-4cb7-bda6-7e3756a0ca8e";
-
- @Getter
- @Accessors(fluent = true)
- private static final String defaultOrgName = "braintrustdata.com";
-
- private static final AtomicReference INSTANCE = new AtomicReference<>();
-
@Getter
@Accessors(fluent = true)
private final OpenTelemetrySdk openTelemetry;
diff --git a/test-harness/src/testFixtures/java/dev/braintrust/VCR.java b/test-harness/src/testFixtures/java/dev/braintrust/VCR.java
index 26d95d4c..d1958b88 100644
--- a/test-harness/src/testFixtures/java/dev/braintrust/VCR.java
+++ b/test-harness/src/testFixtures/java/dev/braintrust/VCR.java
@@ -7,6 +7,8 @@
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.github.tomakehurst.wiremock.WireMockServer;
+import com.github.tomakehurst.wiremock.http.RequestMethod;
+import com.github.tomakehurst.wiremock.matching.RequestPatternBuilder;
import com.github.tomakehurst.wiremock.recording.RecordSpecBuilder;
import java.io.IOException;
import java.nio.file.Files;
@@ -15,6 +17,9 @@
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.concurrent.ThreadSafe;
import lombok.Getter;
@@ -36,6 +41,20 @@ public enum VcrMode {
private static final String DEFAULT_CASSETTES_ROOT =
"test-harness/src/testFixtures/resources/cassettes/";
+ /**
+ * URL path prefixes that are excluded from cassette recording on the Braintrust target. In
+ * RECORD mode these paths still proxy to the real backend but are not persisted as cassettes.
+ * In REPLAY mode they receive catch-all stubs so the SDK's calls succeed without real backends.
+ *
+ * Includes:
+ *
+ *
+ * - {@code /otel/} -- OTEL trace/log exports (binary protobuf with dynamic data)
+ *
- {@code /attachment} -- S3 attachment signed-URL requests and status updates
+ *
+ */
+ private static final Set PASSTHROUGH_PATH_PREFIXES = Set.of("/otel/", "/attachment");
+
private final String cassettesRoot;
private final Map proxyMap;
@Getter private final VcrMode mode;
@@ -188,9 +207,84 @@ private void startRecording(String targetBaseUrl) {
LoginBodyRedactingTransformer.NAME,
ForbiddenTextCheckingTransformer.NAME);
+ // For the braintrust target, exclude passthrough paths from cassette recording.
+ // These paths (OTEL exports, attachment uploads) contain dynamic data that doesn't
+ // replay well. The recording proxy still forwards them to the real backend, but
+ // stopRecording() won't persist them as cassette files.
+ // In REPLAY mode, catch-all stubs handle these paths instead.
+ if ("braintrust".equals(mappingsDir)) {
+ String exclusionRegex = buildPassthroughExclusionRegex();
+ recordSpec.onlyRequestsMatching(
+ RequestPatternBuilder.newRequestPattern(
+ RequestMethod.ANY, urlPathMatching(exclusionRegex)));
+ log.info(
+ "Excluding passthrough paths from recording (filter regex: {})",
+ exclusionRegex);
+ }
+
wireMock.startRecording(recordSpec);
}
+ /**
+ * Build a regex that matches any URL path that does NOT start with any of the passthrough path
+ * prefixes. Uses negative lookahead, e.g.: {@code ^(?!/otel/|/attachment).*$}
+ */
+ private static String buildPassthroughExclusionRegex() {
+ var alternatives =
+ PASSTHROUGH_PATH_PREFIXES.stream()
+ .map(Pattern::quote)
+ .collect(Collectors.joining("|"));
+ return "^(?!" + alternatives + ").*$";
+ }
+
+ /**
+ * Register catch-all stubs on the Braintrust WireMock server for paths that are excluded from
+ * cassette recording. These stubs allow the SDK's background calls (OTEL export, attachment
+ * upload) to succeed in REPLAY mode without real backends.
+ */
+ private static void addBraintrustPassthroughStubs(WireMockServer braintrustWireMock) {
+ // OTEL trace and log exports -- return 200 OK.
+ // Actual span/log content is validated via UnitTestSpanExporter in-memory.
+ braintrustWireMock.stubFor(
+ post(urlEqualTo("/otel/v1/traces"))
+ .atPriority(Integer.MAX_VALUE)
+ .willReturn(aResponse().withStatus(200)));
+ braintrustWireMock.stubFor(
+ post(urlEqualTo("/otel/v1/logs"))
+ .atPriority(Integer.MAX_VALUE)
+ .willReturn(aResponse().withStatus(200)));
+
+ // Attachment upload flow:
+ // 1. POST /attachment -> return a fake signed URL pointing back to this WireMock
+ // 2. PUT /s3-upload-stub -> accept the upload with 200 OK
+ // 3. POST /attachment/status -> acknowledge with 200 OK
+ // The fake signed URL routes the S3 PUT back through WireMock so it succeeds
+ // without reaching a real object store.
+ String fakeSignedUrl = braintrustWireMock.baseUrl() + "/s3-upload-stub";
+ String attachmentResponse = "{\"signedUrl\": \"" + fakeSignedUrl + "\", \"headers\": {}}";
+ braintrustWireMock.stubFor(
+ post(urlEqualTo("/attachment"))
+ .atPriority(Integer.MAX_VALUE)
+ .willReturn(
+ aResponse()
+ .withStatus(200)
+ .withHeader("Content-Type", "application/json")
+ .withBody(attachmentResponse)));
+ braintrustWireMock.stubFor(
+ put(urlEqualTo("/s3-upload-stub"))
+ .atPriority(Integer.MAX_VALUE)
+ .willReturn(aResponse().withStatus(200)));
+ braintrustWireMock.stubFor(
+ post(urlEqualTo("/attachment/status"))
+ .atPriority(Integer.MAX_VALUE)
+ .willReturn(aResponse().withStatus(200)));
+
+ log.info(
+ "Added passthrough stubs for OTEL endpoints and attachment upload flow"
+ + " (fake S3 URL: {})",
+ fakeSignedUrl);
+ }
+
/**
* Load recorded JSON mappings and create programmatic stubs for SSE responses. This avoids
* WireMock's issues with SSE playback from JSON mappings.
@@ -231,17 +325,12 @@ private void loadAndCreateProgrammaticStubs() {
}
}
- // Add catch-all stubs for dynamic requests.
- // These requests contain timestamps and dynamic data that change between runs.
+ // Add catch-all stubs for passthrough paths on the Braintrust target.
+ // These endpoints are not recorded as cassettes -- in REPLAY mode we stub them
+ // so the SDK's background calls succeed without real backends.
WireMockServer braintrustWireMock = proxyMap.get("https://api.braintrust.dev");
if (braintrustWireMock != null) {
- // OTLP trace exports - return 200 OK. Actual span content is validated via
- // UnitTestSpanExporter.
- braintrustWireMock.stubFor(
- post(urlEqualTo("/otel/v1/traces"))
- .atPriority(Integer.MAX_VALUE) // lowest priority, fallback only
- .willReturn(aResponse().withStatus(200)));
- log.info("Added catch-all stub for OTLP trace exports");
+ addBraintrustPassthroughStubs(braintrustWireMock);
}
}
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/__files/otel_v1_traces-dd1e558d-523c-4189-bfd0-d1808c9a7233.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/__files/otel_v1_traces-dd1e558d-523c-4189-bfd0-d1808c9a7233.json
deleted file mode 100644
index 329c4d06..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/__files/otel_v1_traces-dd1e558d-523c-4189-bfd0-d1808c9a7233.json
+++ /dev/null
@@ -1 +0,0 @@
-{"Code":"ForbiddenError","Message":"Missing read access to experiment id abc123-http-test, or the experiment does not exist [user_email=andrew@braintrustdata.com] [user_org=braintrustdata.com] [timestamp=1775682178.832]","InternalTraceId":"69d6c282000000005868ea9bb6bc3400","Path":"/otel/v1/traces","Service":"api"}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-011e1cb1-4854-4715-b330-4276c375c9cf.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-011e1cb1-4854-4715-b330-4276c375c9cf.json
deleted file mode 100644
index 12160f41..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-011e1cb1-4854-4715-b330-4276c375c9cf.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "011e1cb1-4854-4715-b330-4276c375c9cf",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CogICrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLQBgoRCg9icmFpbnRydXN0LWphdmESugYKENqprTkl4vicDF3s0/s0IQMSCL3gXVAh3VFbKg9DaGF0IENvbXBsZXRpb24wATnzLYADuX2kGEEWK2U7uX2kGEqsAQoTYnJhaW50cnVzdC5tZXRhZGF0YRKUAQqRAXsicHJvdmlkZXIiOiJvcGVuYWkiLCJyZXF1ZXN0X3BhdGgiOiJjaGF0L2NvbXBsZXRpb25zIiwibW9kZWwiOiJncHQtNG8tbWluaSIsInJlcXVlc3RfYmFzZV91cmkiOiJodHRwOi8vbG9jYWxob3N0OjM3MDA1IiwicmVxdWVzdF9tZXRob2QiOiJQT1NUIn1K1gEKFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SuwEKuAFbeyJmaW5pc2hfcmVhc29uIjoic3RvcCIsImluZGV4IjowLCJsb2dwcm9icyI6bnVsbCwibWVzc2FnZSI6eyJjb250ZW50IjoiVGhlIGNhcGl0YWwgb2YgRnJhbmNlIGlzIFBhcmlzLiIsInJlZnVzYWwiOm51bGwsInJvbGUiOiJhc3Npc3RhbnQiLCJ0b29sX2NhbGxzIjpbXSwidmFsaWQiOnRydWV9LCJ2YWxpZCI6dHJ1ZX1dSi4KGmJyYWludHJ1c3Quc3Bhbl9hdHRyaWJ1dGVzEhAKDnsidHlwZSI6ImxsbSJ9SjIKEWJyYWludHJ1c3QucGFyZW50Eh0KG3Byb2plY3RfbmFtZTpqYXZhLXVuaXQtdGVzdEqRAQoVYnJhaW50cnVzdC5pbnB1dF9qc29uEngKdlt7ImNvbnRlbnQiOiJZb3UgYXJlIGEgaGVscGZ1bCBhc3Npc3RhbnQiLCJyb2xlIjoic3lzdGVtIn0seyJjb250ZW50IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/Iiwicm9sZSI6InVzZXIifV1KbwoSYnJhaW50cnVzdC5tZXRyaWNzElkKV3siY29tcGxldGlvbl90b2tlbnMiOjcsInByb21wdF90b2tlbnMiOjIzLCJ0b2tlbnMiOjMwLCJ0aW1lX3RvX2ZpcnN0X3Rva2VuIjowLjAxNDc4OTA1fXoAhQEBAQAA"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhN1IFIwoAMEFLg=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c353-2c7284dc7d1c0b5b376f593d;Parent=4478c8e0e3b5a8b7;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:06:27 GMT",
- "Via" : "1.1 b521abc69f4dd055f355de798c5fb95a.cloudfront.net (CloudFront), 1.1 74e8c76139b8c7f9b11d5e4441c2a7a2.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c353000000005f2c9a36bc9e5c9f",
- "x-amzn-RequestId" : "c3690721-7f1c-40c8-b3a3-b78a5ad69cb4",
- "X-Amz-Cf-Id" : "8qvf-DzL23JWPfJKPBlf61_Cua_vBh5z8Lmeb82CuRxUKUzqQV4a6Q==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "011e1cb1-4854-4715-b330-4276c375c9cf",
- "persistent" : true,
- "insertionIndex" : 153
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-0583545e-9c03-414a-9243-7d8d03d99a94.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-0583545e-9c03-414a-9243-7d8d03d99a94.json
deleted file mode 100644
index 63af8e94..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-0583545e-9c03-414a-9243-7d8d03d99a94.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "0583545e-9c03-414a-9243-7d8d03d99a94",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "Cu8HCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjYtYzY3NjFlMgogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBK3BgoRCg9icmFpbnRydXN0LWphdmESoQYKEMb5rDSOS6u1UGerItzcGiESCJlE8FS7LNU1Kg9DaGF0IENvbXBsZXRpb24wATkQuitEpsisGEHQ9ytopsisGEqRAQoVYnJhaW50cnVzdC5pbnB1dF9qc29uEngKdlt7ImNvbnRlbnQiOiJZb3UgYXJlIGEgaGVscGZ1bCBhc3Npc3RhbnQiLCJyb2xlIjoic3lzdGVtIn0seyJjb250ZW50IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/Iiwicm9sZSI6InVzZXIifV1KcAoSYnJhaW50cnVzdC5tZXRyaWNzEloKWHsiY29tcGxldGlvbl90b2tlbnMiOjcsInByb21wdF90b2tlbnMiOjIzLCJ0b2tlbnMiOjMwLCJ0aW1lX3RvX2ZpcnN0X3Rva2VuIjowLjAwNzE2OTQxNn1KLgoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSEAoOeyJ0eXBlIjoibGxtIn1KMgoRYnJhaW50cnVzdC5wYXJlbnQSHQobcHJvamVjdF9uYW1lOmphdmEtdW5pdC10ZXN0SrwBChZicmFpbnRydXN0Lm91dHB1dF9qc29uEqEBCp4BW3siZmluaXNoX3JlYXNvbiI6InN0b3AiLCJpbmRleCI6MCwibG9ncHJvYnMiOm51bGwsIm1lc3NhZ2UiOnsiY29udGVudCI6IlRoZSBjYXBpdGFsIG9mIEZyYW5jZSBpcyBQYXJpcy4iLCJyZWZ1c2FsIjpudWxsLCJyb2xlIjoiYXNzaXN0YW50IiwidG9vbF9jYWxscyI6W119fV1KrAEKE2JyYWludHJ1c3QubWV0YWRhdGESlAEKkQF7InByb3ZpZGVyIjoib3BlbmFpIiwicmVxdWVzdF9wYXRoIjoiY2hhdC9jb21wbGV0aW9ucyIsIm1vZGVsIjoiZ3B0LTRvLW1pbmkiLCJyZXF1ZXN0X2Jhc2VfdXJpIjoiaHR0cDovL2xvY2FsaG9zdDo2MTQyOSIsInJlcXVlc3RfbWV0aG9kIjoiUE9TVCJ9egCFAQEBAAA="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "c6QhIGeJoAMEEow=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SFO53-P8", "SFO53-P1" ],
- "X-Amzn-Trace-Id" : "Root=1-69fa613a-775ac6ea1ee86e342dc61a99;Parent=72dd6c0f00472e06;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Tue, 05 May 2026 21:29:30 GMT",
- "Via" : "1.1 78084fc122c4500a240b888394ad4976.cloudfront.net (CloudFront), 1.1 459b85c545909b647abc5dea4320a0da.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69fa613a0000000065df853c605795d3",
- "x-amzn-RequestId" : "17d6ec8b-ec3e-46d3-aed6-0a1a2d78f24c",
- "X-Amz-Cf-Id" : "7rWOJ_5F-lDZbKtu8kRjwJRj5LmAXiDRrDK6p-9k9ftDanQtgMh4tg==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "0583545e-9c03-414a-9243-7d8d03d99a94",
- "persistent" : true,
- "insertionIndex" : 255
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-07f3ba51-9124-43c0-9655-096f687a37e5.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-07f3ba51-9124-43c0-9655-096f687a37e5.json
deleted file mode 100644
index 796bea54..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-07f3ba51-9124-43c0-9655-096f687a37e5.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "07f3ba51-9124-43c0-9655-096f687a37e5",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CpoICrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLiBgogCg9icmFpbnRydXN0LWphdmESDTAuMy4wLTFjMDRhZjASxAEKELW8NUd+g8wUASFQfG0uV2sSCL6vrHShCzrhIghPdibaSxtLGyoEdGFzazABOTzr3IiCfaQYQQB64IiCfaQYSi8KGmJyYWludHJ1c3Quc3Bhbl9hdHRyaWJ1dGVzEhEKD3sidHlwZSI6InRhc2sifUpJChFicmFpbnRydXN0LnBhcmVudBI0CjJleHBlcmltZW50X2lkOjJiNzRjNmYwLWNiOWEtNGRkZC1hMzBlLTk3YWFlY2ZkZWQ5OHoAhQEBAQAAErkCChC1vDVHfoPMFAEhUHxtLldrEgjJPQKTfVjFjiIIT3Ym2ksbSxsqBXNjb3JlMAE5jtHiiIJ9pBhBIbfliIJ9pBhKJAoRYnJhaW50cnVzdC5zY29yZXMSDwoNeyJleGFjdCI6MS4wfUpSChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxI0CjJ7InR5cGUiOiJzY29yZSIsIm5hbWUiOiJleGFjdCIsInB1cnBvc2UiOiJzY29yZXIifUpJChFicmFpbnRydXN0LnBhcmVudBI0CjJleHBlcmltZW50X2lkOjJiNzRjNmYwLWNiOWEtNGRkZC1hMzBlLTk3YWFlY2ZkZWQ5OEopChZicmFpbnRydXN0Lm91dHB1dF9qc29uEg8KDXsiZXhhY3QiOjEuMH16AIUBAQEAABK6AgoQtbw1R36DzBQBIVB8bS5XaxIIT3Ym2ksbSxsqBGV2YWwwAzm+8NmIgn2kGEGoLOaIgn2kGEosChVicmFpbnRydXN0LmlucHV0X2pzb24SEwoReyJpbnB1dCI6ImhlbGxvIn1KLwoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSEQoPeyJ0eXBlIjoiZXZhbCJ9SkkKEWJyYWludHJ1c3QucGFyZW50EjQKMmV4cGVyaW1lbnRfaWQ6MmI3NGM2ZjAtY2I5YS00ZGRkLWEzMGUtOTdhYWVjZmRlZDk4Si4KFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SFAoSeyJvdXRwdXQiOiJ3b3JsZCJ9SiAKE2JyYWludHJ1c3QuZXhwZWN0ZWQSCQoHIndvcmxkInoAhQEBAQAA"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNQ-GnWIAMEmRQ=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c26c-36dbe941107581631a66c040;Parent=118c7dd6e5f40128;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:02:36 GMT",
- "Via" : "1.1 49e28fce48b0172be48e0ceea533547e.cloudfront.net (CloudFront), 1.1 a624be98cd5b264f373d8ac17f78ee50.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c26c0000000004b398e3f5ca7c04",
- "x-amzn-RequestId" : "7c86e063-ccf7-4c86-ab0c-3dac088b1490",
- "X-Amz-Cf-Id" : "DUu_mb-P2uH0qeNDUOayohh9z_g-BRUO9HGxNsOIXy6oQALTIcSGQQ==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "07f3ba51-9124-43c0-9655-096f687a37e5",
- "persistent" : true,
- "insertionIndex" : 53
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-09fb5b68-31ad-43b5-890d-7e3c4615a0a8.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-09fb5b68-31ad-43b5-890d-7e3c4615a0a8.json
deleted file mode 100644
index 7d86bd48..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-09fb5b68-31ad-43b5-890d-7e3c4615a0a8.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "09fb5b68-31ad-43b5-890d-7e3c4615a0a8",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNzVEMvIAMEksQ=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c348-5a00abd36f02fa764f669629;Parent=014fd240b30720f8;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:06:16 GMT",
- "Via" : "1.1 2be627c4e85d6d9d9e32a7523e1b67ee.cloudfront.net (CloudFront), 1.1 0eb43913f9caf453beb959a8a836a688.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c348000000001eb9a665b9e0f972",
- "x-amzn-RequestId" : "d58fc128-89e3-4585-84cc-ec5e8af16eae",
- "X-Amz-Cf-Id" : "PQfFCnA_p_YS0KRPjqz9UFPx8dn_Uhgd2WNn3DyTeh205euReJomhg==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "09fb5b68-31ad-43b5-890d-7e3c4615a0a8",
- "persistent" : true,
- "insertionIndex" : 148
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-0dc779a9-c4c6-4d33-a27e-be1470d944d4.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-0dc779a9-c4c6-4d33-a27e-be1470d944d4.json
deleted file mode 100644
index 822493b3..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-0dc779a9-c4c6-4d33-a27e-be1470d944d4.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "0dc779a9-c4c6-4d33-a27e-be1470d944d4",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cqZhlEVYIAMEc6A=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69f4093c-25c852796a77af6f1a0360d3;Parent=50a62496a8f4149e;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Fri, 01 May 2026 02:00:29 GMT",
- "Via" : "1.1 2d0eb1433209b25c3712ac0793d56bc0.cloudfront.net (CloudFront), 1.1 ee5f8da78d4211a93c9dba8864a4067e.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69f4093c0000000079500891b1a40e14",
- "x-amzn-RequestId" : "5126ef74-5aa3-417d-b327-c50991fe6cb0",
- "X-Amz-Cf-Id" : "hP0Yr0fT3l99UodDz9C9q3uqJUr_WaJtadt5KaX0Cin6TX0q3dMBEw==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "0dc779a9-c4c6-4d33-a27e-be1470d944d4",
- "persistent" : true,
- "insertionIndex" : 233
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-0e25b74f-5ac9-4bf8-8d05-a670c244e616.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-0e25b74f-5ac9-4bf8-8d05-a670c244e616.json
deleted file mode 100644
index e764632c..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-0e25b74f-5ac9-4bf8-8d05-a670c244e616.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "0e25b74f-5ac9-4bf8-8d05-a670c244e616",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CvwICrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKhAQoFCgNidHgSlwEKEKhvryThVyH7FuLJefqNMH8SCPdVqDMm6CdSKgtjb21wbGV0aW9uczABOQ8bMZyMfaQYQSWFOWaNfaQYSjIKEWJyYWludHJ1c3QucGFyZW50Eh0KG3Byb2plY3RfbmFtZTpqYXZhLXVuaXQtdGVzdEocCgZjbGllbnQSEgoQbGFuZ2NoYWluLW9wZW5haXoAhQEBAQAAEqAGChEKD2JyYWludHJ1c3QtamF2YRKKBgoQqG+vJOFXIfsW4sl5+o0wfxIIagDUmdH7IrEiCPdVqDMm6CdSKg9DaGF0IENvbXBsZXRpb24wAzlKTV6cjH2kGEFtUDJmjX2kGEouChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxIQCg57InR5cGUiOiJsbG0ifUoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3RKkQEKFWJyYWludHJ1c3QuaW5wdXRfanNvbhJ4CnZbeyJyb2xlIjoic3lzdGVtIiwiY29udGVudCI6InlvdSBhcmUgYSBoZWxwZnVsIGFzc2lzdGFudCJ9LHsicm9sZSI6InVzZXIiLCJjb250ZW50IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/In1dSk4KEmJyYWludHJ1c3QubWV0cmljcxI4CjZ7ImNvbXBsZXRpb25fdG9rZW5zIjo3LCJwcm9tcHRfdG9rZW5zIjoyMywidG9rZW5zIjozMH1KrAEKE2JyYWludHJ1c3QubWV0YWRhdGESlAEKkQF7InByb3ZpZGVyIjoib3BlbmFpIiwicmVxdWVzdF9wYXRoIjoiY2hhdC9jb21wbGV0aW9ucyIsIm1vZGVsIjoiZ3B0LTRvLW1pbmkiLCJyZXF1ZXN0X2Jhc2VfdXJpIjoiaHR0cDovL2xvY2FsaG9zdDo0MTUzMyIsInJlcXVlc3RfbWV0aG9kIjoiUE9TVCJ9Sr0BChZicmFpbnRydXN0Lm91dHB1dF9qc29uEqIBCp8BW3siaW5kZXgiOjAsIm1lc3NhZ2UiOnsicm9sZSI6ImFzc2lzdGFudCIsImNvbnRlbnQiOiJUaGUgY2FwaXRhbCBvZiBGcmFuY2UgaXMgUGFyaXMuIiwicmVmdXNhbCI6bnVsbCwiYW5ub3RhdGlvbnMiOltdfSwibG9ncHJvYnMiOm51bGwsImZpbmlzaF9yZWFzb24iOiJzdG9wIn1degCFAQEBAAA="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNYfGEroAMEFRw=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c29c-12fffcc37b661156339d5703;Parent=0d43374e61514a49;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:03:24 GMT",
- "Via" : "1.1 b7e07d6a19a4c8b2e410e9c1e173548c.cloudfront.net (CloudFront), 1.1 82fa7f20ab5a12301da8e01f9493e222.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c29c000000002ec3c968c583fa30",
- "x-amzn-RequestId" : "83b228bc-41fc-47dd-84ed-7c667b8c7721",
- "X-Amz-Cf-Id" : "7cdqamBRC7-uuhJrnGkzddhMGMoRvleYU7hdMqjBjEievKJALMozxg==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "0e25b74f-5ac9-4bf8-8d05-a670c244e616",
- "persistent" : true,
- "insertionIndex" : 136
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-0ed09ca4-ea5c-41ed-a044-80008fbf0a45.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-0ed09ca4-ea5c-41ed-a044-80008fbf0a45.json
deleted file mode 100644
index afc0c865..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-0ed09ca4-ea5c-41ed-a044-80008fbf0a45.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "0ed09ca4-ea5c-41ed-a044-80008fbf0a45",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNV0HkYoAMEPRQ=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c28b-2783574615ed63f9352be9d7;Parent=524524da2d1f9e86;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:03:07 GMT",
- "Via" : "1.1 d5e9313fa5148ebdba4664d3e2a90f58.cloudfront.net (CloudFront), 1.1 ffe9646b2ea911744e2d51fc0715cedc.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c28b000000003f009338e4604b3b",
- "x-amzn-RequestId" : "4a96d5ac-63fc-4539-8964-5fb18da43a4a",
- "X-Amz-Cf-Id" : "5rtt0aXgSzELpxJTKeJHwUsH3XwzW6Yz-6zkBKFc5LWrPRP9xYuYZQ==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "0ed09ca4-ea5c-41ed-a044-80008fbf0a45",
- "persistent" : true,
- "insertionIndex" : 139
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-16e37454-11f7-4aa1-a9f6-8b9dee6d3a89.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-16e37454-11f7-4aa1-a9f6-8b9dee6d3a89.json
deleted file mode 100644
index e9082fb2..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-16e37454-11f7-4aa1-a9f6-8b9dee6d3a89.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "16e37454-11f7-4aa1-a9f6-8b9dee6d3a89",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CsEICrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjYtYzY3NjFlMgogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKJBwoRCg9icmFpbnRydXN0LWphdmES8wYKEEZ8++JSi6pYQ6HzNvs2+ZISCMLoRwqe63tKKglyZXNwb25zZXMwATnwcT9/psisGEGE1jwgp8isGEpqChVicmFpbnRydXN0LmlucHV0X2pzb24SUQpPW3siY29udGVudCI6IldoYXQgaXMgdGhlIGNhcGl0YWwgb2YgRnJhbmNlPyBSZXBseSBpbiBvbmUgd29yZC4iLCJyb2xlIjoidXNlciJ9XUpvChJicmFpbnRydXN0Lm1ldHJpY3MSWQpXeyJjb21wbGV0aW9uX3Rva2VucyI6MzgsInByb21wdF90b2tlbnMiOjE4LCJ0b2tlbnMiOjU2LCJjb21wbGV0aW9uX3JlYXNvbmluZ190b2tlbnMiOjB9Si4KGmJyYWludHJ1c3Quc3Bhbl9hdHRyaWJ1dGVzEhAKDnsidHlwZSI6ImxsbSJ9SjIKEWJyYWludHJ1c3QucGFyZW50Eh0KG3Byb2plY3RfbmFtZTpqYXZhLXVuaXQtdGVzdErIAgoWYnJhaW50cnVzdC5vdXRwdXRfanNvbhKtAgqqAlt7ImlkIjoicnNfMDM2NTIwZTIxNjllZmE3NDAwNjlmYTYxM2I5M2E0ODE5NWIzOGY2OGE4Nzc1MjRmZDIiLCJ0eXBlIjoicmVhc29uaW5nIiwic3VtbWFyeSI6W119LHsiaWQiOiJtc2dfMDM2NTIwZTIxNjllZmE3NDAwNjlmYTYxM2M3NjMwODE5NTgyY2MxMjRjNDU1OWM3ZTAiLCJ0eXBlIjoibWVzc2FnZSIsInN0YXR1cyI6ImNvbXBsZXRlZCIsImNvbnRlbnQiOlt7InR5cGUiOiJvdXRwdXRfdGV4dCIsImFubm90YXRpb25zIjpbXSwibG9ncHJvYnMiOltdLCJ0ZXh0IjoiUGFyaXMifV0sInJvbGUiOiJhc3Npc3RhbnQifV1KoQEKE2JyYWludHJ1c3QubWV0YWRhdGESiQEKhgF7InByb3ZpZGVyIjoib3BlbmFpIiwicmVxdWVzdF9wYXRoIjoicmVzcG9uc2VzIiwibW9kZWwiOiJvNC1taW5pIiwicmVxdWVzdF9iYXNlX3VyaSI6Imh0dHA6Ly9sb2NhbGhvc3Q6NjE0MjkiLCJyZXF1ZXN0X21ldGhvZCI6IlBPU1QifXoAhQEBAQAA"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "c6QhmF92IAMEHXw=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SFO53-P8", "SFO53-P1" ],
- "X-Amzn-Trace-Id" : "Root=1-69fa613d-7798a4a30ad1a01e6e660890;Parent=13c5353e1e5e26a9;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Tue, 05 May 2026 21:29:33 GMT",
- "Via" : "1.1 1192096cca5216ce826d805f95b99ae6.cloudfront.net (CloudFront), 1.1 6db0e3fcf85d00de1ac587c2611daca6.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69fa613d000000002c7e4eecc90d4549",
- "x-amzn-RequestId" : "c7f89a2d-f180-47ba-b4ad-c45cb9134870",
- "X-Amz-Cf-Id" : "R0FrNjEns2U_5ezsVYRqlj8Syu8w8vTeHb_4q_gNwSfXC3fxgqTKWA==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "16e37454-11f7-4aa1-a9f6-8b9dee6d3a89",
- "persistent" : true,
- "insertionIndex" : 254
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-1d1288a6-581d-4a46-8194-4d81acc38c95.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-1d1288a6-581d-4a46-8194-4d81acc38c95.json
deleted file mode 100644
index 74dbcd82..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-1d1288a6-581d-4a46-8194-4d81acc38c95.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "1d1288a6-581d-4a46-8194-4d81acc38c95",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CvQJCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBK8CAogCg9icmFpbnRydXN0LWphdmESDTAuMy4wLTFjMDRhZjASxAEKEC6LyTWCZ4Knq9P2HZCcHb8SCECthb6sSLRpIggMGAo+jzURNSoEdGFzazABObtG/P+BfaQYQUg4/v+BfaQYSi8KGmJyYWludHJ1c3Quc3Bhbl9hdHRyaWJ1dGVzEhEKD3sidHlwZSI6InRhc2sifUpJChFicmFpbnRydXN0LnBhcmVudBI0CjJleHBlcmltZW50X2lkOjllOWU2YmI2LTM4MWYtNDhjMC1iMDQwLWMwMjUyNjIzMGU4M3oAhQEBAQAAErkCChAui8k1gmeCp6vT9h2QnB2/Egj1q0DvBnA+cCIIDBgKPo81ETUqBXNjb3JlMAE5lIkAAIJ9pBhBdEUDAIJ9pBhKJAoRYnJhaW50cnVzdC5zY29yZXMSDwoNeyJleGFjdCI6MC4wfUpSChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxI0CjJ7InR5cGUiOiJzY29yZSIsIm5hbWUiOiJleGFjdCIsInB1cnBvc2UiOiJzY29yZXIifUpJChFicmFpbnRydXN0LnBhcmVudBI0CjJleHBlcmltZW50X2lkOjllOWU2YmI2LTM4MWYtNDhjMC1iMDQwLWMwMjUyNjIzMGU4M0opChZicmFpbnRydXN0Lm91dHB1dF9qc29uEg8KDXsiZXhhY3QiOjAuMH16AIUBAQEAABKUBAoQLovJNYJngqer0/YdkJwdvxIIDBgKPo81ETUqBGV2YWwwAzmJdtH/gX2kGEFFqgMAgn2kGEosChVicmFpbnRydXN0LmlucHV0X2pzb24SEwoReyJpbnB1dCI6ImFwcGxlIn1KLwoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSEQoPeyJ0eXBlIjoiZXZhbCJ9SkkKEWJyYWludHJ1c3QucGFyZW50EjQKMmV4cGVyaW1lbnRfaWQ6OWU5ZTZiYjYtMzgxZi00OGMwLWIwNDAtYzAyNTI2MjMwZTgzStcBChFicmFpbnRydXN0Lm9yaWdpbhLBAQq+AXsib2JqZWN0X3R5cGUiOiJkYXRhc2V0Iiwib2JqZWN0X2lkIjoiMDg1NWIyOWMtNjliYS00Zjk4LTkxNTQtNjFhNDAzMzRhNDkyIiwiaWQiOiJkNTM1MTNmZS00N2U2LTRmNzItODU2Zi04YWE4OTdmZmNiYWUiLCJfeGFjdF9pZCI6IjEwMDAxOTY1MzQxNDEyNzcxNTgiLCJjcmVhdGVkIjoiMjAyNi0wMS0yM1QwMTo0Njo0MC4wNjdaIn1KLgoWYnJhaW50cnVzdC5vdXRwdXRfanNvbhIUChJ7Im91dHB1dCI6IkFQUExFIn1KIAoTYnJhaW50cnVzdC5leHBlY3RlZBIJCgciZnJ1aXQiegCFAQEBAAA="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNQFGJCoAMESiQ=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c266-73d22c3948f640cd23a27350;Parent=4dd4ffb98e8e0287;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:02:30 GMT",
- "Via" : "1.1 5e599a9eda8861379cfef6a522da18e4.cloudfront.net (CloudFront), 1.1 82fa7f20ab5a12301da8e01f9493e222.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c26600000000433e24d9eeaf7557",
- "x-amzn-RequestId" : "3cc43dc9-7c35-42a0-930c-4a846f8ac4cf",
- "X-Amz-Cf-Id" : "OYSOUKPX0dCPU2335SEB7p6LS8mUvuWVM5dQJkQmJvMPIZLBRabkaw==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "1d1288a6-581d-4a46-8194-4d81acc38c95",
- "persistent" : true,
- "insertionIndex" : 69
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-243e5745-1f02-42d0-9e1a-5d2bba6776ca.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-243e5745-1f02-42d0-9e1a-5d2bba6776ca.json
deleted file mode 100644
index ab303f85..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-243e5745-1f02-42d0-9e1a-5d2bba6776ca.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "243e5745-1f02-42d0-9e1a-5d2bba6776ca",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNPOG54oAMEgPQ=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c261-647a2e500dbbbf0e40571ad2;Parent=017961fb768381b5;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:02:25 GMT",
- "Via" : "1.1 2be627c4e85d6d9d9e32a7523e1b67ee.cloudfront.net (CloudFront), 1.1 b669d9add7767f73665f1f8b7e8cd802.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c26100000000045d8799560d5531",
- "x-amzn-RequestId" : "ae8e9b56-7d79-4bae-abc8-15700f44b92a",
- "X-Amz-Cf-Id" : "7J-A1zkpXlrBoTyHJ-ODRFitb4RxJQwkecQaFfUJpIf8WY6CF1_vHw==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "243e5745-1f02-42d0-9e1a-5d2bba6776ca",
- "persistent" : true,
- "insertionIndex" : 80
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-24796634-260b-49b0-8ca1-e8c0dd1441e2.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-24796634-260b-49b0-8ca1-e8c0dd1441e2.json
deleted file mode 100644
index d134b868..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-24796634-260b-49b0-8ca1-e8c0dd1441e2.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "24796634-260b-49b0-8ca1-e8c0dd1441e2",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CpQZCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLcFwogCg9icmFpbnRydXN0LWphdmESDTAuMy4wLTFjMDRhZjAS1gIKEHrmTb6VpfPN4jkgk5f3LOASCOa7l5xgvdCuIgh5tcoTCUcqICoEdGFzazABOVmqCQKAfaQYQY+qFAKAfaQYSiwKFWJyYWludHJ1c3QuaW5wdXRfanNvbhITChF7ImlucHV0IjoiYXBwbGUifUpgChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxJCCkB7InR5cGUiOiJ0YXNrIiwibmFtZSI6InRhc2siLCJnZW5lcmF0aW9uIjoidGVzdC1nZW4tc2NvcmVyLWVyciJ9SkkKEWJyYWludHJ1c3QucGFyZW50EjQKMnBsYXlncm91bmRfaWQ6Y2VlYTc0MjItMzUwNy00ZDFjLWE1ZjctN2FjZjQxZDlmYWMySi8KFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SFQoTeyJvdXRwdXQiOiJyZXN1bHQifVABegCFAQEBAAAS7A4KEHrmTb6VpfPN4jkgk5f3LOASCKTLm5sj16LYIgh5tcoTCUcqICoFc2NvcmUwATkLyBkCgH2kGEHv5SACgH2kGEosChFicmFpbnRydXN0LnNjb3JlcxIXChV7ImJyb2tlbl9zY29yZXIiOjAuMH1KfQoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSXwpdeyJ0eXBlIjoic2NvcmUiLCJuYW1lIjoiYnJva2VuX3Njb3JlciIsInB1cnBvc2UiOiJzY29yZXIiLCJnZW5lcmF0aW9uIjoidGVzdC1nZW4tc2NvcmVyLWVyciJ9SkkKEWJyYWludHJ1c3QucGFyZW50EjQKMnBsYXlncm91bmRfaWQ6Y2VlYTc0MjItMzUwNy00ZDFjLWE1ZjctN2FjZjQxZDlmYWMySjEKFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SFwoVeyJicm9rZW5fc2NvcmVyIjowLjB9UAFa3wsJhYIeAoB9pBgSCWV4Y2VwdGlvbhrvCgoUZXhjZXB0aW9uLnN0YWNrdHJhY2US1goK0wpqYXZhLmxhbmcuUnVudGltZUV4Y2VwdGlvbjogc2NvcmVyIGlzIGJyb2tlbgoJYXQgZGV2LmJyYWludHJ1c3QuZGV2c2VydmVyLkRldnNlcnZlclRlc3QkMS5zY29yZShEZXZzZXJ2ZXJUZXN0LmphdmE6MTA4KQoJYXQgZGV2LmJyYWludHJ1c3QuZGV2c2VydmVyLkRldnNlcnZlci5ydW5TY29yZXIoRGV2c2VydmVyLmphdmE6NzA4KQoJYXQgZGV2LmJyYWludHJ1c3QuZGV2c2VydmVyLkRldnNlcnZlci5sYW1iZGEkaGFuZGxlU3RyZWFtaW5nRXZhbCQwKERldnNlcnZlci5qYXZhOjUyMCkKCWF0IGRldi5icmFpbnRydXN0LmV2YWwuRGF0YXNldCRDdXJzb3IuZm9yRWFjaChEYXRhc2V0LmphdmE6NTMpCglhdCBkZXYuYnJhaW50cnVzdC5ldmFsLkRhdGFzZXQuZm9yRWFjaChEYXRhc2V0LmphdmE6MjgpCglhdCBkZXYuYnJhaW50cnVzdC5kZXZzZXJ2ZXIuRGV2c2VydmVyLmhhbmRsZVN0cmVhbWluZ0V2YWwoRGV2c2VydmVyLmphdmE6NDA4KQoJYXQgZGV2LmJyYWludHJ1c3QuZGV2c2VydmVyLkRldnNlcnZlci5oYW5kbGVFdmFsKERldnNlcnZlci5qYXZhOjMzNCkKCWF0IGRldi5icmFpbnRydXN0LmRldnNlcnZlci5EZXZzZXJ2ZXIubGFtYmRhJHdpdGhDb3JzJDMoRGV2c2VydmVyLmphdmE6OTQ0KQoJYXQgamRrLmh0dHBzZXJ2ZXIvY29tLnN1bi5uZXQuaHR0cHNlcnZlci5GaWx0ZXIkQ2hhaW4uZG9GaWx0ZXIoRmlsdGVyLmphdmE6OTUpCglhdCBqZGsuaHR0cHNlcnZlci9zdW4ubmV0Lmh0dHBzZXJ2ZXIuQXV0aEZpbHRlci5kb0ZpbHRlcihBdXRoRmlsdGVyLmphdmE6ODIpCglhdCBqZGsuaHR0cHNlcnZlci9jb20uc3VuLm5ldC5odHRwc2VydmVyLkZpbHRlciRDaGFpbi5kb0ZpbHRlcihGaWx0ZXIuamF2YTo5OCkKCWF0IGpkay5odHRwc2VydmVyL3N1bi5uZXQuaHR0cHNlcnZlci5TZXJ2ZXJJbXBsJEV4Y2hhbmdlJExpbmtIYW5kbGVyLmhhbmRsZShTZXJ2ZXJJbXBsLmphdmE6ODU1KQoJYXQgamRrLmh0dHBzZXJ2ZXIvY29tLnN1bi5uZXQuaHR0cHNlcnZlci5GaWx0ZXIkQ2hhaW4uZG9GaWx0ZXIoRmlsdGVyLmphdmE6OTUpCglhdCBqZGsuaHR0cHNlcnZlci9zdW4ubmV0Lmh0dHBzZXJ2ZXIuU2VydmVySW1wbCRFeGNoYW5nZS5ydW4oU2VydmVySW1wbC5qYXZhOjgzMSkKCWF0IGphdmEuYmFzZS9qYXZhLnV0aWwuY29uY3VycmVudC5UaHJlYWRQb29sRXhlY3V0b3IucnVuV29ya2VyKFRocmVhZFBvb2xFeGVjdXRvci5qYXZhOjExMzYpCglhdCBqYXZhLmJhc2UvamF2YS51dGlsLmNvbmN1cnJlbnQuVGhyZWFkUG9vbEV4ZWN1dG9yJFdvcmtlci5ydW4oVGhyZWFkUG9vbEV4ZWN1dG9yLmphdmE6NjM1KQoJYXQgamF2YS5iYXNlL2phdmEubGFuZy5UaHJlYWQucnVuKFRocmVhZC5qYXZhOjg0MCkKGi4KDmV4Y2VwdGlvbi50eXBlEhwKGmphdmEubGFuZy5SdW50aW1lRXhjZXB0aW9uGicKEWV4Y2VwdGlvbi5tZXNzYWdlEhIKEHNjb3JlciBpcyBicm9rZW56FBIQc2NvcmVyIGlzIGJyb2tlbhgChQEBAQAAEvkCChB65k2+laXzzeI5IJOX9yzgEgjGG33rmqLCWiIIebXKEwlHKiAqBXNjb3JlMAE5RtAhAoB9pBhBJ/YjAoB9pBhKLQoRYnJhaW50cnVzdC5zY29yZXMSGAoWeyJ3b3JraW5nX3Njb3JlciI6MS4wfUp+ChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxJgCl57InR5cGUiOiJzY29yZSIsIm5hbWUiOiJ3b3JraW5nX3Njb3JlciIsInB1cnBvc2UiOiJzY29yZXIiLCJnZW5lcmF0aW9uIjoidGVzdC1nZW4tc2NvcmVyLWVyciJ9SkkKEWJyYWludHJ1c3QucGFyZW50EjQKMnBsYXlncm91bmRfaWQ6Y2VlYTc0MjItMzUwNy00ZDFjLWE1ZjctN2FjZjQxZDlmYWMySjIKFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SGAoWeyJ3b3JraW5nX3Njb3JlciI6MS4wfVABegCFAQEBAAAS8wIKEHrmTb6VpfPN4jkgk5f3LOASCHm1yhMJRyogKgRldmFsMAM5e88HAoB9pBhBhoEkAoB9pBhKLAoVYnJhaW50cnVzdC5pbnB1dF9qc29uEhMKEXsiaW5wdXQiOiJhcHBsZSJ9SmAKGmJyYWludHJ1c3Quc3Bhbl9hdHRyaWJ1dGVzEkIKQHsidHlwZSI6ImV2YWwiLCJuYW1lIjoiZXZhbCIsImdlbmVyYXRpb24iOiJ0ZXN0LWdlbi1zY29yZXItZXJyIn1KSQoRYnJhaW50cnVzdC5wYXJlbnQSNAoycGxheWdyb3VuZF9pZDpjZWVhNzQyMi0zNTA3LTRkMWMtYTVmNy03YWNmNDFkOWZhYzJKJQoYYnJhaW50cnVzdC5leHBlY3RlZF9qc29uEgkKByJmcnVpdCJKLwoWYnJhaW50cnVzdC5vdXRwdXRfanNvbhIVChN7Im91dHB1dCI6InJlc3VsdCJ9UAF6AIUBAQEAAA=="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNOuGkMIAMEliw=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c25d-1e146042606d9408228f796b;Parent=2e0e8cad95e8a7de;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:02:22 GMT",
- "Via" : "1.1 b7e07d6a19a4c8b2e410e9c1e173548c.cloudfront.net (CloudFront), 1.1 a53bab1af200813b8f27e3c0a28b4964.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c25d00000000088c6574cb0edbaf",
- "x-amzn-RequestId" : "9ea53408-d030-416c-a420-48a0dbb1eac0",
- "X-Amz-Cf-Id" : "1vceFeeYDKm_DSVIX14m3aOxRVv4HidhWHZ5CxpaDY7FUpYdHV1hqg==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "24796634-260b-49b0-8ca1-e8c0dd1441e2",
- "persistent" : true,
- "insertionIndex" : 87
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-24c753bf-40ff-4a23-8d2e-1194e2091ba4.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-24c753bf-40ff-4a23-8d2e-1194e2091ba4.json
deleted file mode 100644
index 8c1449e6..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-24c753bf-40ff-4a23-8d2e-1194e2091ba4.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "24c753bf-40ff-4a23-8d2e-1194e2091ba4",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CuoCCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKyAQogCg9icmFpbnRydXN0LWphdmESDTAuMy4wLTFjMDRhZjASjQEKEOyEFYKtWRabrBdJFTKfOkASCOihoqx+cC+GKg51bml0LXRlc3Qtcm9vdDABOWGhUmyIfaQYQedyU2yIfaQYSjIKEWJyYWludHJ1c3QucGFyZW50Eh0KG3Byb2plY3RfbmFtZTpqYXZhLXVuaXQtdGVzdEoPCgl1bml0LXRlc3QSAhABegCFAQEBAAA="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNUYHxdIAMEpYA=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c282-33061d725caa5cd41a7e441e;Parent=37683ceea4c7e4e1;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:02:58 GMT",
- "Via" : "1.1 b7e07d6a19a4c8b2e410e9c1e173548c.cloudfront.net (CloudFront), 1.1 f8731007efc5ab360d90cee573a1e916.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c2820000000020e4d2265d230949",
- "x-amzn-RequestId" : "c52c8c45-066f-4bce-b32d-e519fb5c17c4",
- "X-Amz-Cf-Id" : "JQTRoiSXwMb59T2dIe3N4LfZSAcxfV1raB3m86v37sK5_92CGCKSCQ==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "24c753bf-40ff-4a23-8d2e-1194e2091ba4",
- "persistent" : true,
- "insertionIndex" : 2
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-24d38c9a-65ac-46b4-8a76-8361fcefb5eb.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-24d38c9a-65ac-46b4-8a76-8361fcefb5eb.json
deleted file mode 100644
index e8f5bd05..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-24d38c9a-65ac-46b4-8a76-8361fcefb5eb.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "24d38c9a-65ac-46b4-8a76-8361fcefb5eb",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cqZdcFzyoAMEfqw=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69f40922-70468c0e469cf9a626f381e1;Parent=7850182c85deb76d;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Fri, 01 May 2026 02:00:02 GMT",
- "Via" : "1.1 2d0eb1433209b25c3712ac0793d56bc0.cloudfront.net (CloudFront), 1.1 a624be98cd5b264f373d8ac17f78ee50.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69f40922000000002c5766c51deba7a7",
- "x-amzn-RequestId" : "04e4807a-3caa-4277-9c01-9285f8340a85",
- "X-Amz-Cf-Id" : "SdnDpAX9fvbo7mZF1KQ6tSpa6Zjq2BWzI9mFxVYKqHoEBWw7npoh5Q==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "24d38c9a-65ac-46b4-8a76-8361fcefb5eb",
- "persistent" : true,
- "insertionIndex" : 235
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-25d130bf-c522-4329-afbf-6b6b7259a752.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-25d130bf-c522-4329-afbf-6b6b7259a752.json
deleted file mode 100644
index 3258c08b..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-25d130bf-c522-4329-afbf-6b6b7259a752.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "25d130bf-c522-4329-afbf-6b6b7259a752",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CpAHCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLYBQoRCg9icmFpbnRydXN0LWphdmESwgUKEDu4LbfolAOWCOjFHbANE2QSCPrfVxlBPEqxKg9DaGF0IENvbXBsZXRpb24wATl1A2vkvH2kGEENVY0uvX2kGEouChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxIQCg57InR5cGUiOiJsbG0ifUoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3RKVwoVYnJhaW50cnVzdC5pbnB1dF9qc29uEj4KPFt7ImNvbnRlbnQiOiJXaGF0IGlzIHRoZSBjYXBpdGFsIG9mIEZyYW5jZT8iLCJyb2xlIjoidXNlciJ9XUpwChJicmFpbnRydXN0Lm1ldHJpY3MSWgpYeyJjb21wbGV0aW9uX3Rva2VucyI6NywicHJvbXB0X3Rva2VucyI6MTQsInRva2VucyI6MjEsInRpbWVfdG9fZmlyc3RfdG9rZW4iOjEuMjA1NDcxNDU2fUq3AQoTYnJhaW50cnVzdC5tZXRhZGF0YRKfAQqcAXsicHJvdmlkZXIiOiJvcGVuYWkiLCJyZXF1ZXN0X3BhdGgiOiJjaGF0L2NvbXBsZXRpb25zIiwibW9kZWwiOiJncHQtNG8tbWluaS0yMDI0LTA3LTE4IiwicmVxdWVzdF9iYXNlX3VyaSI6Imh0dHA6Ly9sb2NhbGhvc3Q6MzY4MDEiLCJyZXF1ZXN0X21ldGhvZCI6IlBPU1QifUqLAQoWYnJhaW50cnVzdC5vdXRwdXRfanNvbhJxCm9beyJtZXNzYWdlIjp7InJvbGUiOiJhc3Npc3RhbnQiLCJjb250ZW50IjoiVGhlIGNhcGl0YWwgb2YgRnJhbmNlIGlzIFBhcmlzLiJ9LCJpbmRleCI6MCwiZmluaXNoX3JlYXNvbiI6InN0b3AifV1QAXoAhQEBAQAA"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhN3-EIcIAMEFzg=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c365-170cc99f0116b82c53d8ca42;Parent=28b1bcf209e522ea;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:06:46 GMT",
- "Via" : "1.1 b521abc69f4dd055f355de798c5fb95a.cloudfront.net (CloudFront), 1.1 82fa7f20ab5a12301da8e01f9493e222.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c365000000001564d73e50b7eb85",
- "x-amzn-RequestId" : "a3f2d8d2-b290-40f9-ac35-891a9da09a78",
- "X-Amz-Cf-Id" : "Xt5_urTxjpVatpzb2wQ-BoO3FXJ84MiW4fBghyioYfU0jDWAX_e9eA==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "25d130bf-c522-4329-afbf-6b6b7259a752",
- "persistent" : true,
- "insertionIndex" : 157
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-280b119b-97a6-4689-b660-9d7c32ca5ba4.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-280b119b-97a6-4689-b660-9d7c32ca5ba4.json
deleted file mode 100644
index 803c7e4f..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-280b119b-97a6-4689-b660-9d7c32ca5ba4.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "280b119b-97a6-4689-b660-9d7c32ca5ba4",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNb8HxdIAMEgPQ=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c2b2-206236ff372835cf4eadb844;Parent=18a03030ad56d2c5;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:03:46 GMT",
- "Via" : "1.1 724581b48d733e53834b535d2a623034.cloudfront.net (CloudFront), 1.1 82fa7f20ab5a12301da8e01f9493e222.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c2b2000000002870739896bd811b",
- "x-amzn-RequestId" : "39ab4390-2057-4369-8850-bcd4daaea0fc",
- "X-Amz-Cf-Id" : "wvPM7GlmEOD38uxHVvoAph4ijWZ2zZnUY5o-uiUE9awpxDaHTrQAOg==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "280b119b-97a6-4689-b660-9d7c32ca5ba4",
- "persistent" : true,
- "insertionIndex" : 131
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-29a53860-e392-4587-ba18-bba1d2e1b581.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-29a53860-e392-4587-ba18-bba1d2e1b581.json
deleted file mode 100644
index a8d2110c..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-29a53860-e392-4587-ba18-bba1d2e1b581.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "29a53860-e392-4587-ba18-bba1d2e1b581",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CogKCrgBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAooCg9zZXJ2aWNlLnZlcnNpb24SFQoTMC4zLjQtNjgyMGIwYi1ESVJUWQogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLKCAoRCg9icmFpbnRydXN0LWphdmEStAgKEHxZUUtff/x0GmdwpB715GASCAq8fihaIP7WKhBnZW5lcmF0ZV9jb250ZW50MAM5gNthbbYKqxhBkHCyqbYKqxhKygEKFWJyYWludHJ1c3QuaW5wdXRfanNvbhKwAQqtAXsiY29udGVudHMiOlt7InBhcnRzIjpbeyJ0ZXh0IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBHZXJtYW55PyJ9XSwicm9sZSI6InVzZXIifV0sIm1vZGVsIjoiZ2VtaW5pLTMuMS1mbGFzaC1saXRlLXByZXZpZXciLCJjb25maWciOnsidGVtcGVyYXR1cmUiOjAuMCwibWF4T3V0cHV0VG9rZW5zIjo1MH19Sk0KEmJyYWludHJ1c3QubWV0cmljcxI3CjV7ImNvbXBsZXRpb25fdG9rZW5zIjo3LCJwcm9tcHRfdG9rZW5zIjo4LCJ0b2tlbnMiOjE1fUouChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxIQCg57InR5cGUiOiJsbG0ifUoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3RK5gMKFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SywMKyAN7ImNhbmRpZGF0ZXMiOlt7ImNvbnRlbnQiOnsicGFydHMiOlt7InRleHQiOiJUaGUgY2FwaXRhbCBvZiBHZXJtYW55IGlzIEJlcmxpbi4iLCJ0aG91Z2h0U2lnbmF0dXJlIjoiRWpRS01nRU1PZGJIK21KSzB4VnhXb25QOWV6WklhL1FhU1BKeTJ1U0FiMFdlUEdsRi9tVFVDRVJRczc1dE14NDZnUzlVeHNEIn1dLCJyb2xlIjoibW9kZWwifSwiZmluaXNoUmVhc29uIjoiU1RPUCIsImluZGV4IjowfV0sInVzYWdlTWV0YWRhdGEiOnsicHJvbXB0VG9rZW5Db3VudCI6OCwiY2FuZGlkYXRlc1Rva2VuQ291bnQiOjcsInRvdGFsVG9rZW5Db3VudCI6MTUsInByb21wdFRva2Vuc0RldGFpbHMiOlt7Im1vZGFsaXR5IjoiVEVYVCIsInRva2VuQ291bnQiOjh9XX0sIm1vZGVsVmVyc2lvbiI6ImdlbWluaS0zLjEtZmxhc2gtbGl0ZS1wcmV2aWV3IiwicmVzcG9uc2VJZCI6IjhlWHlhZGo0SU1UaXF0c1BwN2JpOFFNIn1KfQoTYnJhaW50cnVzdC5tZXRhZGF0YRJmCmR7InByb3ZpZGVyIjoiZ2VtaW5pIiwidGVtcGVyYXR1cmUiOjAuMCwibW9kZWwiOiJnZW1pbmktMy4xLWZsYXNoLWxpdGUtcHJldmlldyIsIm1heE91dHB1dFRva2VucyI6NTB9egIYAYUBAQEAAA=="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cnjd2HUEoAMEduQ=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69f2e5f1-6e22bcc6160c24fd03aed954;Parent=0bc473e98f7d08ec;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Thu, 30 Apr 2026 05:17:38 GMT",
- "Via" : "1.1 8022fb6dd967fd5734dda3b51415b460.cloudfront.net (CloudFront), 1.1 65f2e9f7f1475de54aa452d3ceb9bcf6.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69f2e5f100000000169650fc41b6cab8",
- "x-amzn-RequestId" : "16496122-d01d-4764-bf5b-9326d91755c4",
- "X-Amz-Cf-Id" : "-Vzypmbtmq6NjThWrP5oJLxtZKHPT7JaWI_uf0kRU3N_wpXK7q6UfQ==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "29a53860-e392-4587-ba18-bba1d2e1b581",
- "persistent" : true,
- "insertionIndex" : 237
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-2afb2972-0d1e-4792-96fd-6a12e3524961.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-2afb2972-0d1e-4792-96fd-6a12e3524961.json
deleted file mode 100644
index 34501e03..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-2afb2972-0d1e-4792-96fd-6a12e3524961.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "2afb2972-0d1e-4792-96fd-6a12e3524961",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CpQKCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLcCAoRCg9icmFpbnRydXN0LWphdmESxggKEArwIuYXXZdpbu/oYAknMJYSCKscf1Xa2tTwKhlhbnRocm9waWMubWVzc2FnZXMuY3JlYXRlMAE5cOSqk7B9pBhBx183t7B9pBhKkQEKFWJyYWludHJ1c3QuaW5wdXRfanNvbhJ4CnZbeyJjb250ZW50IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/Iiwicm9sZSI6InVzZXIifSx7InJvbGUiOiJzeXN0ZW0iLCJjb250ZW50IjoiWW91IGFyZSBhIGhlbHBmdWwgYXNzaXN0YW50In1dSk8KEmJyYWludHJ1c3QubWV0cmljcxI5Cjd7ImNvbXBsZXRpb25fdG9rZW5zIjoxMCwicHJvbXB0X3Rva2VucyI6MTksInRva2VucyI6Mjl9SjIKEWJyYWludHJ1c3QucGFyZW50Eh0KG3Byb2plY3RfbmFtZTpqYXZhLXVuaXQtdGVzdEouChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxIQCg57InR5cGUiOiJsbG0ifUqEBAoWYnJhaW50cnVzdC5vdXRwdXRfanNvbhLpAwrmA3sibW9kZWwiOiJjbGF1ZGUtMy1oYWlrdS0yMDI0MDMwNyIsImlkIjoibXNnXzAxQUNpaVlmRXdycFdpZGFFblN3d294aCIsInR5cGUiOiJtZXNzYWdlIiwicm9sZSI6ImFzc2lzdGFudCIsImNvbnRlbnQiOlt7InR5cGUiOiJ0ZXh0IiwidGV4dCI6IlRoZSBjYXBpdGFsIG9mIEZyYW5jZSBpcyBQYXJpcy4ifV0sInN0b3BfcmVhc29uIjoiZW5kX3R1cm4iLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGwsInVzYWdlIjp7ImlucHV0X3Rva2VucyI6MTksImNhY2hlX2NyZWF0aW9uX2lucHV0X3Rva2VucyI6MCwiY2FjaGVfcmVhZF9pbnB1dF90b2tlbnMiOjAsImNhY2hlX2NyZWF0aW9uIjp7ImVwaGVtZXJhbF81bV9pbnB1dF90b2tlbnMiOjAsImVwaGVtZXJhbF8xaF9pbnB1dF90b2tlbnMiOjB9LCJvdXRwdXRfdG9rZW5zIjoxMCwic2VydmljZV90aWVyIjoic3RhbmRhcmQiLCJpbmZlcmVuY2VfZ2VvIjoibm90X2F2YWlsYWJsZSJ9fUqgAQoTYnJhaW50cnVzdC5tZXRhZGF0YRKIAQqFAXsicHJvdmlkZXIiOiJhbnRocm9waWMiLCJyZXF1ZXN0X3BhdGgiOiJ2MS9tZXNzYWdlcyIsIm1vZGVsIjoiY2xhdWRlLTMtaGFpa3UtMjAyNDAzMDciLCJyZXF1ZXN0X2Jhc2VfdXJpIjoiIiwicmVxdWVzdF9tZXRob2QiOiJQT1NUIn16AIUBAQEAAA=="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNvbF0moAMER2g=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c32f-34111e052990b9f510dbf3a5;Parent=27d9bd02d716657a;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:05:51 GMT",
- "Via" : "1.1 b521abc69f4dd055f355de798c5fb95a.cloudfront.net (CloudFront), 1.1 65f2e9f7f1475de54aa452d3ceb9bcf6.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c32f0000000039119316dad7ef48",
- "x-amzn-RequestId" : "62345d7b-4f11-4171-9b8c-e5a35265ff31",
- "X-Amz-Cf-Id" : "gyatPxGFNE2XiKmntQ5PitO5ggsxdjcnk2zIVmYAcsNwGPZkS3jSHA==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "2afb2972-0d1e-4792-96fd-6a12e3524961",
- "persistent" : true,
- "insertionIndex" : 144
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-345e8cfc-b988-4f27-b4ba-f22847ec2339.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-345e8cfc-b988-4f27-b4ba-f22847ec2339.json
deleted file mode 100644
index 61f791af..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-345e8cfc-b988-4f27-b4ba-f22847ec2339.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "345e8cfc-b988-4f27-b4ba-f22847ec2339",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "Cs4HCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjYtYzY3NjFlMgogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKWBgoRCg9icmFpbnRydXN0LWphdmESgAYKEK+JCZSpp0MqG/X7yghAIp8SCHrhvpfbRR+BKg9DaGF0IENvbXBsZXRpb24wATkQgxaFp8isGEHBE52np8isGEqRAQoVYnJhaW50cnVzdC5pbnB1dF9qc29uEngKdlt7ImNvbnRlbnQiOiJZb3UgYXJlIGEgaGVscGZ1bCBhc3Npc3RhbnQiLCJyb2xlIjoic3lzdGVtIn0seyJjb250ZW50IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/Iiwicm9sZSI6InVzZXIifV1KTgoSYnJhaW50cnVzdC5tZXRyaWNzEjgKNnsiY29tcGxldGlvbl90b2tlbnMiOjcsInByb21wdF90b2tlbnMiOjIzLCJ0b2tlbnMiOjMwfUouChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxIQCg57InR5cGUiOiJsbG0ifUoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3RKvQEKFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SogEKnwFbeyJpbmRleCI6MCwibWVzc2FnZSI6eyJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6IlRoZSBjYXBpdGFsIG9mIEZyYW5jZSBpcyBQYXJpcy4iLCJyZWZ1c2FsIjpudWxsLCJhbm5vdGF0aW9ucyI6W119LCJsb2dwcm9icyI6bnVsbCwiZmluaXNoX3JlYXNvbiI6InN0b3AifV1KrAEKE2JyYWludHJ1c3QubWV0YWRhdGESlAEKkQF7InByb3ZpZGVyIjoib3BlbmFpIiwicmVxdWVzdF9wYXRoIjoiY2hhdC9jb21wbGV0aW9ucyIsIm1vZGVsIjoiZ3B0LTRvLW1pbmkiLCJyZXF1ZXN0X2Jhc2VfdXJpIjoiaHR0cDovL2xvY2FsaG9zdDo2MTQyOSIsInJlcXVlc3RfbWV0aG9kIjoiUE9TVCJ9egCFAQEBAAA="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "c6Qh_FOYoAMEPfg=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SFO53-P8", "SFO53-P1" ],
- "X-Amzn-Trace-Id" : "Root=1-69fa613f-4723e14f09767f9516db1517;Parent=243bfd2d2bc539b8;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Tue, 05 May 2026 21:29:35 GMT",
- "Via" : "1.1 f87d91065dc3f8a4150aaedb0d948cd8.cloudfront.net (CloudFront), 1.1 c8c3180933886633be93f042334d6e12.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69fa613f000000004edb3095136d04d9",
- "x-amzn-RequestId" : "4eb00730-a76f-47a7-bcf8-80296ca9b19b",
- "X-Amz-Cf-Id" : "kozl9H8Hf9U5Ex6V76f775BUA0fHiBQWvstZzMOOB8pwg1z42wvPPg==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "345e8cfc-b988-4f27-b4ba-f22847ec2339",
- "persistent" : true,
- "insertionIndex" : 252
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-3b0b6a2c-c723-47e0-b2ad-850ffc55da6f.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-3b0b6a2c-c723-47e0-b2ad-850ffc55da6f.json
deleted file mode 100644
index e8904976..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-3b0b6a2c-c723-47e0-b2ad-850ffc55da6f.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "3b0b6a2c-c723-47e0-b2ad-850ffc55da6f",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cqZb1GrZoAMEFqA=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69f40918-03b036a6094b0fca3378742c;Parent=5384ca44a88e633b;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Fri, 01 May 2026 01:59:52 GMT",
- "Via" : "1.1 21c7c4234f218bb5110262cbbf01f870.cloudfront.net (CloudFront), 1.1 d9d466ed70d93f34739969f91577ec74.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69f40918000000006296838770277ebe",
- "x-amzn-RequestId" : "b9cfdb28-ba12-43fe-aa1a-405fd5269dcd",
- "X-Amz-Cf-Id" : "sQ3e8dgL3-jz8W1t-RrY_cwvdWVsOgMtKNQOyHw0eBHgJ4_sEwofuA==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "3b0b6a2c-c723-47e0-b2ad-850ffc55da6f",
- "persistent" : true,
- "insertionIndex" : 236
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-3b281011-14e1-453e-8ff0-d1637fb2aad1.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-3b281011-14e1-453e-8ff0-d1637fb2aad1.json
deleted file mode 100644
index a2831ba5..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-3b281011-14e1-453e-8ff0-d1637fb2aad1.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "3b281011-14e1-453e-8ff0-d1637fb2aad1",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CssUCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKTEwogCg9icmFpbnRydXN0LWphdmESDTAuMy4wLTFjMDRhZjASxAEKEGbT/MHTwmI0OR94TxgfPa4SCNfAoRt56v+rIghv5eyo8Io4sioEdGFzazABOXUFio+EfaQYQXhYi4+EfaQYSi8KGmJyYWludHJ1c3Quc3Bhbl9hdHRyaWJ1dGVzEhEKD3sidHlwZSI6InRhc2sifUpJChFicmFpbnRydXN0LnBhcmVudBI0CjJleHBlcmltZW50X2lkOjJiNzRjNmYwLWNiOWEtNGRkZC1hMzBlLTk3YWFlY2ZkZWQ5OHoAhQEBAQAAEs4CChBm0/zB08JiNDkfeE8YHz2uEghwAaj70SW8DyIIb+XsqPCKOLIqBXNjb3JlMAE5lMeMj4R9pBhBBxKPj4R9pBhKKwoRYnJhaW50cnVzdC5zY29yZXMSFgoUeyJmcnVpdF9zY29yZXIiOjAuMH1KWQoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSOwo5eyJ0eXBlIjoic2NvcmUiLCJuYW1lIjoiZnJ1aXRfc2NvcmVyIiwicHVycG9zZSI6InNjb3JlciJ9SkkKEWJyYWludHJ1c3QucGFyZW50EjQKMmV4cGVyaW1lbnRfaWQ6MmI3NGM2ZjAtY2I5YS00ZGRkLWEzMGUtOTdhYWVjZmRlZDk4SjAKFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SFgoUeyJmcnVpdF9zY29yZXIiOjAuMH16AIUBAQEAABLaAgoQZtP8wdPCYjQ5H3hPGB89rhIIbmO3Z6j41UUiCG/l7KjwijiyKgVzY29yZTABOR+jj4+EfaQYQdvQkI+EfaQYSi8KEWJyYWludHJ1c3Quc2NvcmVzEhoKGHsidmVnZXRhYmxlX3Njb3JlciI6MC4wfUpdChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxI/Cj17InR5cGUiOiJzY29yZSIsIm5hbWUiOiJ2ZWdldGFibGVfc2NvcmVyIiwicHVycG9zZSI6InNjb3JlciJ9SkkKEWJyYWludHJ1c3QucGFyZW50EjQKMmV4cGVyaW1lbnRfaWQ6MmI3NGM2ZjAtY2I5YS00ZGRkLWEzMGUtOTdhYWVjZmRlZDk4SjQKFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SGgoYeyJ2ZWdldGFibGVfc2NvcmVyIjowLjB9egCFAQEBAAASvwIKEGbT/MHTwmI0OR94TxgfPa4SCG/l7KjwijiyKgRldmFsMAM5H+aHj4R9pBhB3RWRj4R9pBhKMQoVYnJhaW50cnVzdC5pbnB1dF9qc29uEhgKFnsiaW5wdXQiOiJzdHJhd2JlcnJ5In1KLwoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSEQoPeyJ0eXBlIjoiZXZhbCJ9SkkKEWJyYWludHJ1c3QucGFyZW50EjQKMmV4cGVyaW1lbnRfaWQ6MmI3NGM2ZjAtY2I5YS00ZGRkLWEzMGUtOTdhYWVjZmRlZDk4Si4KFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SFAoSeyJvdXRwdXQiOiJmcnVpdCJ9SiAKE2JyYWludHJ1c3QuZXhwZWN0ZWQSCQoHImZydWl0InoAhQEBAQAAEsQBChD5jxcUmZ3bBj05rMYE61VcEgiMCS9nCmEcCiIIGnL4xyabxnsqBHRhc2swATloLJOPhH2kGEFGzZOPhH2kGEovChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxIRCg97InR5cGUiOiJ0YXNrIn1KSQoRYnJhaW50cnVzdC5wYXJlbnQSNAoyZXhwZXJpbWVudF9pZDoyYjc0YzZmMC1jYjlhLTRkZGQtYTMwZS05N2FhZWNmZGVkOTh6AIUBAQEAABLOAgoQ+Y8XFJmd2wY9OazGBOtVXBIIhAC2KHZf8SAiCBpy+Mcmm8Z7KgVzY29yZTABOW5LlI+EfaQYQYFqlY+EfaQYSisKEWJyYWludHJ1c3Quc2NvcmVzEhYKFHsiZnJ1aXRfc2NvcmVyIjowLjB9SlkKGmJyYWludHJ1c3Quc3Bhbl9hdHRyaWJ1dGVzEjsKOXsidHlwZSI6InNjb3JlIiwibmFtZSI6ImZydWl0X3Njb3JlciIsInB1cnBvc2UiOiJzY29yZXIifUpJChFicmFpbnRydXN0LnBhcmVudBI0CjJleHBlcmltZW50X2lkOjJiNzRjNmYwLWNiOWEtNGRkZC1hMzBlLTk3YWFlY2ZkZWQ5OEowChZicmFpbnRydXN0Lm91dHB1dF9qc29uEhYKFHsiZnJ1aXRfc2NvcmVyIjowLjB9egCFAQEBAAAS2gIKEPmPFxSZndsGPTmsxgTrVVwSCK/iqxRwpd0LIggacvjHJpvGeyoFc2NvcmUwATnB55WPhH2kGEHmCZePhH2kGEovChFicmFpbnRydXN0LnNjb3JlcxIaChh7InZlZ2V0YWJsZV9zY29yZXIiOjAuMH1KXQoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSPwo9eyJ0eXBlIjoic2NvcmUiLCJuYW1lIjoidmVnZXRhYmxlX3Njb3JlciIsInB1cnBvc2UiOiJzY29yZXIifUpJChFicmFpbnRydXN0LnBhcmVudBI0CjJleHBlcmltZW50X2lkOjJiNzRjNmYwLWNiOWEtNGRkZC1hMzBlLTk3YWFlY2ZkZWQ5OEo0ChZicmFpbnRydXN0Lm91dHB1dF9qc29uEhoKGHsidmVnZXRhYmxlX3Njb3JlciI6MC4wfXoAhQEBAQAAEsICChD5jxcUmZ3bBj05rMYE61VcEggacvjHJpvGeyoEZXZhbDADOelEko+EfaQYQTdMl4+EfaQYSjAKFWJyYWludHJ1c3QuaW5wdXRfanNvbhIXChV7ImlucHV0IjoiYXNwYXJhZ3VzIn1KLwoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSEQoPeyJ0eXBlIjoiZXZhbCJ9SkkKEWJyYWludHJ1c3QucGFyZW50EjQKMmV4cGVyaW1lbnRfaWQ6MmI3NGM2ZjAtY2I5YS00ZGRkLWEzMGUtOTdhYWVjZmRlZDk4Si4KFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SFAoSeyJvdXRwdXQiOiJmcnVpdCJ9SiQKE2JyYWludHJ1c3QuZXhwZWN0ZWQSDQoLInZlZ2V0YWJsZSJ6AIUBAQEAAA=="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNR4H36oAMEaRA=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c272-6b130fba768a03d76d07b086;Parent=392d2019637dcafe;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:02:42 GMT",
- "Via" : "1.1 49e28fce48b0172be48e0ceea533547e.cloudfront.net (CloudFront), 1.1 da32b45f2cc22dc818960285c4e91b66.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c272000000002ed6a2f5b6a96b33",
- "x-amzn-RequestId" : "7e7ccb91-026b-4490-aa69-6959142c311f",
- "X-Amz-Cf-Id" : "yDCdxMWye319GFdgP6VxxdNAG2VAW_t_uA3TN_z7jVAI5gPOOpK6vQ==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "3b281011-14e1-453e-8ff0-d1637fb2aad1",
- "persistent" : true,
- "insertionIndex" : 38
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-3c47c7ba-8cf2-43e1-a9cc-a1e8aa985f65.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-3c47c7ba-8cf2-43e1-a9cc-a1e8aa985f65.json
deleted file mode 100644
index e2efe720..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-3c47c7ba-8cf2-43e1-a9cc-a1e8aa985f65.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "3c47c7ba-8cf2-43e1-a9cc-a1e8aa985f65",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CoUKCrgBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAooCg9zZXJ2aWNlLnZlcnNpb24SFQoTMC4zLjQtNjgyMGIwYi1ESVJUWQogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLHCAoRCg9icmFpbnRydXN0LWphdmESsQgKEIJtWjsd38UI78ctbaGWXloSCPxHOTwfRWs9KhBnZW5lcmF0ZV9jb250ZW50MAM5ID7b17YKqxhB5yBjFLcKqxhKyQEKFWJyYWludHJ1c3QuaW5wdXRfanNvbhKvAQqsAXsiY29udGVudHMiOlt7InBhcnRzIjpbeyJ0ZXh0IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/In1dLCJyb2xlIjoidXNlciJ9XSwibW9kZWwiOiJnZW1pbmktMy4xLWZsYXNoLWxpdGUtcHJldmlldyIsImNvbmZpZyI6eyJ0ZW1wZXJhdHVyZSI6MC4wLCJtYXhPdXRwdXRUb2tlbnMiOjUwfX1KTQoSYnJhaW50cnVzdC5tZXRyaWNzEjcKNXsiY29tcGxldGlvbl90b2tlbnMiOjcsInByb21wdF90b2tlbnMiOjgsInRva2VucyI6MTV9Si4KGmJyYWludHJ1c3Quc3Bhbl9hdHRyaWJ1dGVzEhAKDnsidHlwZSI6ImxsbSJ9SjIKEWJyYWludHJ1c3QucGFyZW50Eh0KG3Byb2plY3RfbmFtZTpqYXZhLXVuaXQtdGVzdErkAwoWYnJhaW50cnVzdC5vdXRwdXRfanNvbhLJAwrGA3siY2FuZGlkYXRlcyI6W3siY29udGVudCI6eyJwYXJ0cyI6W3sidGV4dCI6IlRoZSBjYXBpdGFsIG9mIEZyYW5jZSBpcyBQYXJpcy4iLCJ0aG91Z2h0U2lnbmF0dXJlIjoiRWpRS01nRU1PZGJIWSttM0NETkJLUU05ZEN4VVptUXh6ZUJRNVp4aWcvS2wzdTljVE1IMDNnQUx4ZXFIaHlLdm9QV21OTlFmIn1dLCJyb2xlIjoibW9kZWwifSwiZmluaXNoUmVhc29uIjoiU1RPUCIsImluZGV4IjowfV0sInVzYWdlTWV0YWRhdGEiOnsicHJvbXB0VG9rZW5Db3VudCI6OCwiY2FuZGlkYXRlc1Rva2VuQ291bnQiOjcsInRvdGFsVG9rZW5Db3VudCI6MTUsInByb21wdFRva2Vuc0RldGFpbHMiOlt7Im1vZGFsaXR5IjoiVEVYVCIsInRva2VuQ291bnQiOjh9XX0sIm1vZGVsVmVyc2lvbiI6ImdlbWluaS0zLjEtZmxhc2gtbGl0ZS1wcmV2aWV3IiwicmVzcG9uc2VJZCI6IjgtWHlhY19hRnItaHF0c1B5ZnVaeVFNIn1KfQoTYnJhaW50cnVzdC5tZXRhZGF0YRJmCmR7InByb3ZpZGVyIjoiZ2VtaW5pIiwidGVtcGVyYXR1cmUiOjAuMCwibW9kZWwiOiJnZW1pbmktMy4xLWZsYXNoLWxpdGUtcHJldmlldyIsIm1heE91dHB1dFRva2VucyI6NTB9egIYAYUBAQEAAA=="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cnjeHF1tIAMEQhQ=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69f2e5f3-53624e1730f79ca622013814;Parent=54812060e0a57d2a;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Thu, 30 Apr 2026 05:17:39 GMT",
- "Via" : "1.1 49e28fce48b0172be48e0ceea533547e.cloudfront.net (CloudFront), 1.1 65f2e9f7f1475de54aa452d3ceb9bcf6.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69f2e5f3000000003f51a2c2be3233fb",
- "x-amzn-RequestId" : "62d09c75-ba6c-4a34-82ae-12031fa4a209",
- "X-Amz-Cf-Id" : "pNZQyH3g86Fgrataim4KqzWlvl__0CeZGVfsiVIbQeHWDApkQpmSyA==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "3c47c7ba-8cf2-43e1-a9cc-a1e8aa985f65",
- "persistent" : true,
- "insertionIndex" : 236
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-400677f9-7745-4316-8fcf-fc716be486e7.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-400677f9-7745-4316-8fcf-fc716be486e7.json
deleted file mode 100644
index daba11f1..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-400677f9-7745-4316-8fcf-fc716be486e7.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "400677f9-7745-4316-8fcf-fc716be486e7",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cseFsEM7IAMEbQw=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69f4dd57-35af459139022c3812d2e0b3;Parent=4f937720bf96e133;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Fri, 01 May 2026 17:05:27 GMT",
- "Via" : "1.1 487082619948f670d3b30fb3db8fbabc.cloudfront.net (CloudFront), 1.1 a40ac7dad0e348fc93799233c9af5960.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69f4dd5700000000788f3116ea724408",
- "x-amzn-RequestId" : "0d1712f4-6515-493e-a9dd-802bf663c14c",
- "X-Amz-Cf-Id" : "HVSEmI4hhIs0e6EaqekEbDaonQ6JIX3mk3HLceVUnoEaV8ZXAxgOZQ==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "400677f9-7745-4316-8fcf-fc716be486e7",
- "persistent" : true,
- "insertionIndex" : 245
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-41cf277b-e997-458b-9834-21ce460e60f0.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-41cf277b-e997-458b-9834-21ce460e60f0.json
deleted file mode 100644
index 67ecc1a5..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-41cf277b-e997-458b-9834-21ce460e60f0.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "41cf277b-e997-458b-9834-21ce460e60f0",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CoULCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLNCQoRCg9icmFpbnRydXN0LWphdmEStwkKEHnn96ElV987JTnq0eBpEHQSCNl4eNQjZWurKhlhbnRocm9waWMubWVzc2FnZXMuY3JlYXRlMAE5Tp376LF9pBhBzDe7GbJ9pBhKkQEKFWJyYWludHJ1c3QuaW5wdXRfanNvbhJ4CnZbeyJjb250ZW50IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/Iiwicm9sZSI6InVzZXIifSx7InJvbGUiOiJzeXN0ZW0iLCJjb250ZW50IjoiWW91IGFyZSBhIGhlbHBmdWwgYXNzaXN0YW50In1dSnEKEmJyYWludHJ1c3QubWV0cmljcxJbCll7ImNvbXBsZXRpb25fdG9rZW5zIjoxMCwicHJvbXB0X3Rva2VucyI6MTksInRva2VucyI6MjksInRpbWVfdG9fZmlyc3RfdG9rZW4iOjAuMDAzMzQ5OTI4fUoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3RKLgoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSEAoOeyJ0eXBlIjoibGxtIn1K0wQKFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SuAQKtQR7ImlkIjoibXNnXzAxOWdlMUNWa2djYmp5QlBZRjhoUWVTVSIsImNvbnRlbnQiOlt7ImNpdGF0aW9ucyI6bnVsbCwidGV4dCI6IlRoZSBjYXBpdGFsIG9mIEZyYW5jZSBpcyBQYXJpcy4iLCJ0eXBlIjoidGV4dCIsInZhbGlkIjp0cnVlfV0sIm1vZGVsIjoiY2xhdWRlLTMtaGFpa3UtMjAyNDAzMDciLCJyb2xlIjoiYXNzaXN0YW50Iiwic3RvcF9yZWFzb24iOiJlbmRfdHVybiIsInN0b3Bfc2VxdWVuY2UiOm51bGwsInR5cGUiOiJtZXNzYWdlIiwidXNhZ2UiOnsiY2FjaGVfY3JlYXRpb25faW5wdXRfdG9rZW5zIjowLCJjYWNoZV9yZWFkX2lucHV0X3Rva2VucyI6MCwiaW5wdXRfdG9rZW5zIjoxOSwib3V0cHV0X3Rva2VucyI6MTAsInNlcnZlcl90b29sX3VzZSI6bnVsbCwic2VydmljZV90aWVyIjoic3RhbmRhcmQiLCJ2YWxpZCI6dHJ1ZSwiaW5mZXJlbmNlX2dlbyI6Im5vdF9hdmFpbGFibGUiLCJjYWNoZV9jcmVhdGlvbiI6eyJlcGhlbWVyYWxfNW1faW5wdXRfdG9rZW5zIjowLCJlcGhlbWVyYWxfMWhfaW5wdXRfdG9rZW5zIjowfX0sInZhbGlkIjp0cnVlLCJzdG9wX2RldGFpbHMiOm51bGx9SqABChNicmFpbnRydXN0Lm1ldGFkYXRhEogBCoUBeyJwcm92aWRlciI6ImFudGhyb3BpYyIsInJlcXVlc3RfcGF0aCI6InYxL21lc3NhZ2VzIiwibW9kZWwiOiJjbGF1ZGUtMy1oYWlrdS0yMDI0MDMwNyIsInJlcXVlc3RfYmFzZV91cmkiOiIiLCJyZXF1ZXN0X21ldGhvZCI6IlBPU1QifXoAhQEBAQAA"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNwWGrMIAMEddA=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c335-6ea278a804bf953b7e19041e;Parent=4ae6a2154ed48e94;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:05:57 GMT",
- "Via" : "1.1 5d1052cca98b3bf996fd05529bc2e070.cloudfront.net (CloudFront), 1.1 ee5f8da78d4211a93c9dba8864a4067e.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c335000000002137e410bac88e8d",
- "x-amzn-RequestId" : "e7ddfb57-70a0-4c32-9118-7211443dacbf",
- "X-Amz-Cf-Id" : "heGI2u9TmMgWo7CAMpebWTs2MHo9bOBXmnqJKH9V9RRJPP5YV64v_A==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "41cf277b-e997-458b-9834-21ce460e60f0",
- "persistent" : true,
- "insertionIndex" : 140
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-42c4b63d-ce6a-4de4-964e-0b3295b9f697.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-42c4b63d-ce6a-4de4-964e-0b3295b9f697.json
deleted file mode 100644
index 8a41601a..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-42c4b63d-ce6a-4de4-964e-0b3295b9f697.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "42c4b63d-ce6a-4de4-964e-0b3295b9f697",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cqZWqHxBoAMESxA=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69f408f7-3b8f3a221a6fac600405e5f7;Parent=56c4c0adc911663c;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Fri, 01 May 2026 01:59:19 GMT",
- "Via" : "1.1 21c7c4234f218bb5110262cbbf01f870.cloudfront.net (CloudFront), 1.1 a53bab1af200813b8f27e3c0a28b4964.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69f408f70000000056a29e9dc2ce0895",
- "x-amzn-RequestId" : "14d85b3b-232d-461e-812b-b8f88ea2cfcc",
- "X-Amz-Cf-Id" : "rEHQVZBCzRoaCx9zdiTRApl1v9nhjTfL3A5JyjFGqaPvFB0znROTWA==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "42c4b63d-ce6a-4de4-964e-0b3295b9f697",
- "persistent" : true,
- "insertionIndex" : 241
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-466d1cb2-3345-43b6-9eca-c42dcf21f052.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-466d1cb2-3345-43b6-9eca-c42dcf21f052.json
deleted file mode 100644
index fd9558b4..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-466d1cb2-3345-43b6-9eca-c42dcf21f052.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "466d1cb2-3345-43b6-9eca-c42dcf21f052",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CuACCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKoAQoYChZkaXN0cmlidXRlZC10cmFjZS10ZXN0EosBChBJ5+04UVSinslLHlw82JoNEgglulck7UTPPSoddGVzdC1kaXN0cmlidXRlZC10cmFjZS1wYXJlbnQwATnqS6Rxhn2kGEFwj3T1hn2kGEoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3R6AIUBAQEAAA=="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNTZEe1oAMErhA=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c27b-27645e560538a83c50d28aa7;Parent=6e6da7edb861a893;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:02:51 GMT",
- "Via" : "1.1 724581b48d733e53834b535d2a623034.cloudfront.net (CloudFront), 1.1 ffe9646b2ea911744e2d51fc0715cedc.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c27b00000000297ce67268fcfbfa",
- "x-amzn-RequestId" : "cc5d0940-57c5-4d3a-8db4-c21d8c6b7497",
- "X-Amz-Cf-Id" : "elciWfIffadrh_faGnqKdHZLs6hR3IwF6rehpPNTPn4w5TfG-wcv_Q==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "466d1cb2-3345-43b6-9eca-c42dcf21f052",
- "persistent" : true,
- "insertionIndex" : 16
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-48a52dd8-c9eb-4da0-9c37-81765bb837b0.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-48a52dd8-c9eb-4da0-9c37-81765bb837b0.json
deleted file mode 100644
index 4080754d..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-48a52dd8-c9eb-4da0-9c37-81765bb837b0.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "48a52dd8-c9eb-4da0-9c37-81765bb837b0",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNzNHASIAMEi1Q=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c347-6dbb2b871e2c7f8115647f57;Parent=0e92fb42028e7dfa;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:06:15 GMT",
- "Via" : "1.1 b7e07d6a19a4c8b2e410e9c1e173548c.cloudfront.net (CloudFront), 1.1 7605973575a3551426b82751020317de.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c347000000007b561f2ebfb0de2e",
- "x-amzn-RequestId" : "c8601cdc-b39f-4181-b706-ea25a9342356",
- "X-Amz-Cf-Id" : "DK4AyzMRBjdRWHdoawQqLn8vu0DDu2LHhtVFOIAd7OFjOW1Z1NH30g==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "48a52dd8-c9eb-4da0-9c37-81765bb837b0",
- "persistent" : true,
- "insertionIndex" : 149
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-499535c9-14cf-4285-9008-2dc5bf52b060.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-499535c9-14cf-4285-9008-2dc5bf52b060.json
deleted file mode 100644
index ef3995e7..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-499535c9-14cf-4285-9008-2dc5bf52b060.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "499535c9-14cf-4285-9008-2dc5bf52b060",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CqIICrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLqBgogCg9icmFpbnRydXN0LWphdmESDTAuMy4wLTFjMDRhZjASxAEKEMBwYr5HJ8nznXNAiIAdaEoSCPLGaPHB0rWbIgia+NC+08XriSoEdGFzazABOeThLfGDfaQYQfBfL/GDfaQYSi8KGmJyYWludHJ1c3Quc3Bhbl9hdHRyaWJ1dGVzEhEKD3sidHlwZSI6InRhc2sifUpJChFicmFpbnRydXN0LnBhcmVudBI0CjJleHBlcmltZW50X2lkOjAwM2YyOWNlLTg0NWItNDk4Ny1hMDcyLTFhYTM3ZTJhZmQ0NHoAhQEBAQAAErwCChDAcGK+RyfJ851zQIiAHWhKEgj+5Q4fsHEovyIImvjQvtPF64kqBXNjb3JlMAE5Y/Yw8YN9pBhBgYkz8YN9pBhKJQoRYnJhaW50cnVzdC5zY29yZXMSEAoOeyJzY29yZXIiOjEuMH1KUwoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSNQozeyJ0eXBlIjoic2NvcmUiLCJuYW1lIjoic2NvcmVyIiwicHVycG9zZSI6InNjb3JlciJ9SkkKEWJyYWludHJ1c3QucGFyZW50EjQKMmV4cGVyaW1lbnRfaWQ6MDAzZjI5Y2UtODQ1Yi00OTg3LWEwNzItMWFhMzdlMmFmZDQ0SioKFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SEAoOeyJzY29yZXIiOjEuMH16AIUBAQEAABK/AgoQwHBivkcnyfOdc0CIgB1oShIImvjQvtPF64kqBGV2YWwwAzk36Svxg32kGEG8+jPxg32kGEoxChVicmFpbnRydXN0LmlucHV0X2pzb24SGAoWeyJpbnB1dCI6InN0cmF3YmVycnkifUovChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxIRCg97InR5cGUiOiJldmFsIn1KSQoRYnJhaW50cnVzdC5wYXJlbnQSNAoyZXhwZXJpbWVudF9pZDowMDNmMjljZS04NDViLTQ5ODctYTA3Mi0xYWEzN2UyYWZkNDRKLgoWYnJhaW50cnVzdC5vdXRwdXRfanNvbhIUChJ7Im91dHB1dCI6ImZydWl0In1KIAoTYnJhaW50cnVzdC5leHBlY3RlZBIJCgciZnJ1aXQiegCFAQEBAAA="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNRYFiaIAMEGng=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c26e-6460090d148b234312b37d20;Parent=485bd1fdc28e4cc1;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:02:39 GMT",
- "Via" : "1.1 db84db36e16ca0c80b0992006d731900.cloudfront.net (CloudFront), 1.1 83d24992402f7b214901ab76fbdc11e2.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c26e0000000020e08d84d8463b07",
- "x-amzn-RequestId" : "0c6d866e-53cf-405d-b7e2-1e94db70eb3e",
- "X-Amz-Cf-Id" : "zw8dvZ4zbzAZMHMX7HxIzOtScoTO6lklBf0hEPAk-CmQOJ5wHtfkVw==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "499535c9-14cf-4285-9008-2dc5bf52b060",
- "persistent" : true,
- "insertionIndex" : 46
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-5279636b-7eb9-4959-a3be-de675f1f14e1.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-5279636b-7eb9-4959-a3be-de675f1f14e1.json
deleted file mode 100644
index c563f0da..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-5279636b-7eb9-4959-a3be-de675f1f14e1.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "5279636b-7eb9-4959-a3be-de675f1f14e1",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CvUHCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjEtYmNiODkxZAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBK9BgoYChZicmFpbnRydXN0LWF3cy1iZWRyb2NrEqAGChCA2hVehepKIEuEFdGx6AB0EghUfq2C3tMHKioXYmVkcm9jay5jb252ZXJzZS1zdHJlYW0wATm4F93ZGOanGEF6TM8aGeanGEqDAQoVYnJhaW50cnVzdC5pbnB1dF9qc29uEmoKaFt7InJvbGUiOiJ1c2VyIiwiY29udGVudCI6W3sidGV4dCI6IldoYXQgaXMgdGhlIGNhcGl0YWwgb2YgRnJhbmNlPyBSZXBseSBpbiBvbmUgd29yZC4iLCJ0eXBlIjoidGV4dCJ9XX1dSm0KEmJyYWludHJ1c3QubWV0cmljcxJXClV7ImNvbXBsZXRpb25fdG9rZW5zIjo1LCJwcm9tcHRfdG9rZW5zIjoxOSwidG9rZW5zIjoyNCwidGltZV90b19maXJzdF90b2tlbiI6MC4wMDIwMDF9SjIKEWJyYWludHJ1c3QucGFyZW50Eh0KG3Byb2plY3RfbmFtZTpqYXZhLXVuaXQtdGVzdEouChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxIQCg57InR5cGUiOiJsbG0ifUpeChZicmFpbnRydXN0Lm91dHB1dF9qc29uEkQKQlt7InJvbGUiOiJhc3Npc3RhbnQiLCJjb250ZW50IjpbeyJ0ZXh0IjoiUGFyaXMuIiwidHlwZSI6InRleHQifV19XUqTAgoTYnJhaW50cnVzdC5tZXRhZGF0YRL7AQr4AXsiZW5kcG9pbnQiOiJjb252ZXJzZS1zdHJlYW0iLCJwcm92aWRlciI6ImJlZHJvY2siLCJyZXF1ZXN0X3BhdGgiOiJtb2RlbC91cy5hbnRocm9waWMuY2xhdWRlLTMtaGFpa3UtMjAyNDAzMDctdjElM0EwL2NvbnZlcnNlLXN0cmVhbSIsIm1vZGVsIjoidXMuYW50aHJvcGljLmNsYXVkZS0zLWhhaWt1LTIwMjQwMzA3LXYxOjAiLCJyZXF1ZXN0X2Jhc2VfdXJpIjoiaHR0cDovL2xvY2FsaG9zdCIsInJlcXVlc3RfbWV0aG9kIjoiUE9TVCJ9egCFAQEBAAA="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cFzl-ETKIAMEjRg=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69e56625-441e8c8f2bd4320b17181c96;Parent=6a350a2a27093fd8;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Sun, 19 Apr 2026 23:32:54 GMT",
- "Via" : "1.1 5e599a9eda8861379cfef6a522da18e4.cloudfront.net (CloudFront), 1.1 0eb43913f9caf453beb959a8a836a688.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69e566250000000005daf7e9b40cc191",
- "x-amzn-RequestId" : "cce8cec1-50e4-4dc4-8324-63784d2a19a7",
- "X-Amz-Cf-Id" : "KWmCJgrhWRcuHZOov8b-fY3YLFmZzoPvlOwnkXa1fWoAG9L3DKDicQ==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "5279636b-7eb9-4959-a3be-de675f1f14e1",
- "persistent" : true,
- "insertionIndex" : 164
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-54ca1231-3491-4b83-b678-3b97a45d0e94.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-54ca1231-3491-4b83-b678-3b97a45d0e94.json
deleted file mode 100644
index ba26337a..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-54ca1231-3491-4b83-b678-3b97a45d0e94.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "54ca1231-3491-4b83-b678-3b97a45d0e94",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "Co8ICrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjYtYzY3NjFlMgogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLXBgoRCg9icmFpbnRydXN0LWphdmESwQYKELA8IAbKGggoef5Fhnjo/vsSCOfcCmDedGzEKglyZXNwb25zZXMwATkALpoQqMisGEHlvvw8qMisGEpXChVicmFpbnRydXN0LmlucHV0X2pzb24SPgo8W3siY29udGVudCI6IldoYXQgaXMgdGhlIGNhcGl0YWwgb2YgRnJhbmNlPyIsInJvbGUiOiJ1c2VyIn1dSpABChJicmFpbnRydXN0Lm1ldHJpY3MSegp4eyJjb21wbGV0aW9uX3Rva2VucyI6OCwicHJvbXB0X3Rva2VucyI6MjMsInRva2VucyI6MzEsImNvbXBsZXRpb25fcmVhc29uaW5nX3Rva2VucyI6MCwidGltZV90b19maXJzdF90b2tlbiI6MC4wMDEwOTc2MjV9Si4KGmJyYWludHJ1c3Quc3Bhbl9hdHRyaWJ1dGVzEhAKDnsidHlwZSI6ImxsbSJ9SjIKEWJyYWludHJ1c3QucGFyZW50Eh0KG3Byb2plY3RfbmFtZTpqYXZhLXVuaXQtdGVzdEqDAgoWYnJhaW50cnVzdC5vdXRwdXRfanNvbhLoAQrlAVt7ImlkIjoibXNnXzA4MmQ4ZjkxZmJkNmUzMTgwMDY5ZmE2MTQxODM0ODgxOTZiZTAyN2Y4ZWRjMmYzYjM1IiwiY29udGVudCI6W3siYW5ub3RhdGlvbnMiOltdLCJ0ZXh0IjoiVGhlIGNhcGl0YWwgb2YgRnJhbmNlIGlzIFBhcmlzLiIsInR5cGUiOiJvdXRwdXRfdGV4dCIsImxvZ3Byb2JzIjpbXX1dLCJyb2xlIjoiYXNzaXN0YW50Iiwic3RhdHVzIjoiY29tcGxldGVkIiwidHlwZSI6Im1lc3NhZ2UifV1KpQEKE2JyYWludHJ1c3QubWV0YWRhdGESjQEKigF7InByb3ZpZGVyIjoib3BlbmFpIiwicmVxdWVzdF9wYXRoIjoicmVzcG9uc2VzIiwibW9kZWwiOiJncHQtNG8tbWluaSIsInJlcXVlc3RfYmFzZV91cmkiOiJodHRwOi8vbG9jYWxob3N0OjYxNDI5IiwicmVxdWVzdF9tZXRob2QiOiJQT1NUIn16AIUBAQEAAA=="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "c6QiWH39oAMEcGg=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SFO53-P8", "SFO53-P1" ],
- "X-Amzn-Trace-Id" : "Root=1-69fa6141-5b1e06ab2afe4fe567bfd4a3;Parent=58ac98949191426d;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Tue, 05 May 2026 21:29:38 GMT",
- "Via" : "1.1 5cf315a7bafce190fcf84f55b9019bda.cloudfront.net (CloudFront), 1.1 a11ff1ad6e4c16fe95e18b435889304a.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69fa6141000000000e75b060800dd1e6",
- "x-amzn-RequestId" : "f4fade7d-b72c-4a87-bcc6-d5ffb7399cfe",
- "X-Amz-Cf-Id" : "mjRA0uLjQwhcl1Jjz8Bm0A8vyUghXNlIUwNT4D9DHboB0FwFgJfrBA==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "54ca1231-3491-4b83-b678-3b97a45d0e94",
- "persistent" : true,
- "insertionIndex" : 250
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-54d2a882-99c1-488d-90dc-0462c14ab267.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-54d2a882-99c1-488d-90dc-0462c14ab267.json
deleted file mode 100644
index 7b85ecf2..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-54d2a882-99c1-488d-90dc-0462c14ab267.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "54d2a882-99c1-488d-90dc-0462c14ab267",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CpQKCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLcCAoRCg9icmFpbnRydXN0LWphdmESxggKEOFa1H1yWDqwkrDv7o1xxrMSCDaE5N2uW4osKhlhbnRocm9waWMubWVzc2FnZXMuY3JlYXRlMAE5h2ovMbF9pBhBaW4ZerF9pBhKkQEKFWJyYWludHJ1c3QuaW5wdXRfanNvbhJ4CnZbeyJjb250ZW50IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/Iiwicm9sZSI6InVzZXIifSx7InJvbGUiOiJzeXN0ZW0iLCJjb250ZW50IjoiWW91IGFyZSBhIGhlbHBmdWwgYXNzaXN0YW50In1dSk8KEmJyYWludHJ1c3QubWV0cmljcxI5Cjd7ImNvbXBsZXRpb25fdG9rZW5zIjoxMCwicHJvbXB0X3Rva2VucyI6MTksInRva2VucyI6Mjl9SjIKEWJyYWludHJ1c3QucGFyZW50Eh0KG3Byb2plY3RfbmFtZTpqYXZhLXVuaXQtdGVzdEouChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxIQCg57InR5cGUiOiJsbG0ifUqEBAoWYnJhaW50cnVzdC5vdXRwdXRfanNvbhLpAwrmA3sibW9kZWwiOiJjbGF1ZGUtMy1oYWlrdS0yMDI0MDMwNyIsImlkIjoibXNnXzAxNmZ2Y1lZTEFNZ205SHFvZzVnd1B2YiIsInR5cGUiOiJtZXNzYWdlIiwicm9sZSI6ImFzc2lzdGFudCIsImNvbnRlbnQiOlt7InR5cGUiOiJ0ZXh0IiwidGV4dCI6IlRoZSBjYXBpdGFsIG9mIEZyYW5jZSBpcyBQYXJpcy4ifV0sInN0b3BfcmVhc29uIjoiZW5kX3R1cm4iLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGwsInVzYWdlIjp7ImlucHV0X3Rva2VucyI6MTksImNhY2hlX2NyZWF0aW9uX2lucHV0X3Rva2VucyI6MCwiY2FjaGVfcmVhZF9pbnB1dF90b2tlbnMiOjAsImNhY2hlX2NyZWF0aW9uIjp7ImVwaGVtZXJhbF81bV9pbnB1dF90b2tlbnMiOjAsImVwaGVtZXJhbF8xaF9pbnB1dF90b2tlbnMiOjB9LCJvdXRwdXRfdG9rZW5zIjoxMCwic2VydmljZV90aWVyIjoic3RhbmRhcmQiLCJpbmZlcmVuY2VfZ2VvIjoibm90X2F2YWlsYWJsZSJ9fUqgAQoTYnJhaW50cnVzdC5tZXRhZGF0YRKIAQqFAXsicHJvdmlkZXIiOiJhbnRocm9waWMiLCJyZXF1ZXN0X3BhdGgiOiJ2MS9tZXNzYWdlcyIsIm1vZGVsIjoiY2xhdWRlLTMtaGFpa3UtMjAyNDAzMDciLCJyZXF1ZXN0X2Jhc2VfdXJpIjoiIiwicmVxdWVzdF9tZXRob2QiOiJQT1NUIn16AIUBAQEAAA=="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNv8FyxIAMEliw=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c332-4e6a2f07337eb63d292d675d;Parent=48d958b9d58d9982;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:05:54 GMT",
- "Via" : "1.1 d118b2ea8414d381f46f91331ab67f02.cloudfront.net (CloudFront), 1.1 65f2e9f7f1475de54aa452d3ceb9bcf6.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c3320000000041351ab1f5c486e5",
- "x-amzn-RequestId" : "6e11b7fb-c075-4138-973f-69ac5bc8d25b",
- "X-Amz-Cf-Id" : "lb489ZtPMQU6XCgFgmSr8dlq9qaQ4N4GA0Hqd-9IY4xGjf22axWNlw==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "54d2a882-99c1-488d-90dc-0462c14ab267",
- "persistent" : true,
- "insertionIndex" : 142
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-57070a21-af08-425a-886a-32727f7339dd.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-57070a21-af08-425a-886a-32727f7339dd.json
deleted file mode 100644
index 41489171..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-57070a21-af08-425a-886a-32727f7339dd.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "57070a21-af08-425a-886a-32727f7339dd",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "Cp4HCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjEtYmNiODkxZAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLmBQoYChZicmFpbnRydXN0LWF3cy1iZWRyb2NrEskFChAYsM6KEH7rtL/f/S38lbeJEghu2s+hzIfC/CoQYmVkcm9jay5jb252ZXJzZTABOegxkiQa5qcYQcnSQ1Qa5qcYSoMBChVicmFpbnRydXN0LmlucHV0X2pzb24SagpoW3sicm9sZSI6InVzZXIiLCJjb250ZW50IjpbeyJ0ZXh0IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/IFJlcGx5IGluIG9uZSB3b3JkLiIsInR5cGUiOiJ0ZXh0In1dfV1KTgoSYnJhaW50cnVzdC5tZXRyaWNzEjgKNnsiY29tcGxldGlvbl90b2tlbnMiOjIsInByb21wdF90b2tlbnMiOjEyLCJ0b2tlbnMiOjE0fUoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3RKLgoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSEAoOeyJ0eXBlIjoibGxtIn1KXQoWYnJhaW50cnVzdC5vdXRwdXRfanNvbhJDCkFbeyJjb250ZW50IjpbeyJ0ZXh0IjoiUGFyaXMiLCJ0eXBlIjoidGV4dCJ9XSwicm9sZSI6ImFzc2lzdGFudCJ9XUrjAQoTYnJhaW50cnVzdC5tZXRhZGF0YRLLAQrIAXsiZW5kcG9pbnQiOiJjb252ZXJzZSIsInByb3ZpZGVyIjoiYmVkcm9jayIsInJlcXVlc3RfcGF0aCI6Im1vZGVsL3VzLmFtYXpvbi5ub3ZhLWxpdGUtdjElM0EwL2NvbnZlcnNlIiwibW9kZWwiOiJ1cy5hbWF6b24ubm92YS1saXRlLXYxOjAiLCJyZXF1ZXN0X2Jhc2VfdXJpIjoiaHR0cDovL2xvY2FsaG9zdCIsInJlcXVlc3RfbWV0aG9kIjoiUE9TVCJ9egCFAQEBAAA="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cFzmxHysoAMEmVA=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69e5662a-19ef64fa06e84fe52eca8f87;Parent=5611cc5c45c49577;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Sun, 19 Apr 2026 23:32:59 GMT",
- "Via" : "1.1 e1832834d17ab65dd955f4e68cc524e6.cloudfront.net (CloudFront), 1.1 fbb003dfc0617e3e058e3dac791dfd5a.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69e5662a0000000063fe6666688a9ed4",
- "x-amzn-RequestId" : "d67ec18b-e026-4e21-ad72-7beda6bc696c",
- "X-Amz-Cf-Id" : "QxuOoaWj89tHZf0bf0-Wv39xn9qEVx0EQ6348UBSiiOnEcS8De0NnQ==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "57070a21-af08-425a-886a-32727f7339dd",
- "persistent" : true,
- "insertionIndex" : 162
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-58354206-e4d1-4bd1-aec1-ed83cd4640e5.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-58354206-e4d1-4bd1-aec1-ed83cd4640e5.json
deleted file mode 100644
index 5b5ddb27..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-58354206-e4d1-4bd1-aec1-ed83cd4640e5.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "58354206-e4d1-4bd1-aec1-ed83cd4640e5",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cqZYZG78oAMEhdw=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69f40902-286ed71d4586e6ac609fe735;Parent=65f703ace37a5de6;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Fri, 01 May 2026 01:59:30 GMT",
- "Via" : "1.1 d08613e1dd8ad614e47875ae31a8af20.cloudfront.net (CloudFront), 1.1 96f6dcbb4d7267cad6eb0747bce72024.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69f409020000000040db0310edf73ffb",
- "x-amzn-RequestId" : "4575dbb9-a565-4e3c-bb32-181f3c7639ae",
- "X-Amz-Cf-Id" : "9BsbRFGQsQ3OA8Y7TiFWjDp3k3RDRIHXGvebSoUIyu5QpDhsPN4RyA==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "58354206-e4d1-4bd1-aec1-ed83cd4640e5",
- "persistent" : true,
- "insertionIndex" : 239
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-59a6603c-d3c7-45be-a804-ec799c810646.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-59a6603c-d3c7-45be-a804-ec799c810646.json
deleted file mode 100644
index 8b66b629..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-59a6603c-d3c7-45be-a804-ec799c810646.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "59a6603c-d3c7-45be-a804-ec799c810646",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "Cs4HCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKWBgoRCg9icmFpbnRydXN0LWphdmESgAYKEEEZZJF4kLaqkHSE56pqUEESCHmzCz3mKrEPKg9DaGF0IENvbXBsZXRpb24wATlUukqruH2kGEGD7ZPhuH2kGEqsAQoTYnJhaW50cnVzdC5tZXRhZGF0YRKUAQqRAXsicHJvdmlkZXIiOiJvcGVuYWkiLCJyZXF1ZXN0X3BhdGgiOiJjaGF0L2NvbXBsZXRpb25zIiwibW9kZWwiOiJncHQtNG8tbWluaSIsInJlcXVlc3RfYmFzZV91cmkiOiJodHRwOi8vbG9jYWxob3N0OjM3MDA1IiwicmVxdWVzdF9tZXRob2QiOiJQT1NUIn1KvQEKFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SogEKnwFbeyJpbmRleCI6MCwibWVzc2FnZSI6eyJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6IlRoZSBjYXBpdGFsIG9mIEZyYW5jZSBpcyBQYXJpcy4iLCJyZWZ1c2FsIjpudWxsLCJhbm5vdGF0aW9ucyI6W119LCJsb2dwcm9icyI6bnVsbCwiZmluaXNoX3JlYXNvbiI6InN0b3AifV1KLgoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSEAoOeyJ0eXBlIjoibGxtIn1KMgoRYnJhaW50cnVzdC5wYXJlbnQSHQobcHJvamVjdF9uYW1lOmphdmEtdW5pdC10ZXN0SpEBChVicmFpbnRydXN0LmlucHV0X2pzb24SeAp2W3siY29udGVudCI6IllvdSBhcmUgYSBoZWxwZnVsIGFzc2lzdGFudCIsInJvbGUiOiJzeXN0ZW0ifSx7ImNvbnRlbnQiOiJXaGF0IGlzIHRoZSBjYXBpdGFsIG9mIEZyYW5jZT8iLCJyb2xlIjoidXNlciJ9XUpOChJicmFpbnRydXN0Lm1ldHJpY3MSOAo2eyJjb21wbGV0aW9uX3Rva2VucyI6NywicHJvbXB0X3Rva2VucyI6MjMsInRva2VucyI6MzB9egCFAQEBAAA="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhN05GSoIAMEWlA=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c352-0ec7b0bd526f26836042439d;Parent=3bdd158164c455e5;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:06:26 GMT",
- "Via" : "1.1 5d1052cca98b3bf996fd05529bc2e070.cloudfront.net (CloudFront), 1.1 ee5f8da78d4211a93c9dba8864a4067e.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c352000000006d961369c32c2314",
- "x-amzn-RequestId" : "c71e22e4-a299-4fe6-b828-1007915fd64b",
- "X-Amz-Cf-Id" : "R9Vglsua9B-rmL5xiFq5XnlGtq7K0jA055qMg6DOThSnmOJZ9xXEjA==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "59a6603c-d3c7-45be-a804-ec799c810646",
- "persistent" : true,
- "insertionIndex" : 154
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-5fd4255c-167c-4244-877a-42137be04aba.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-5fd4255c-167c-4244-877a-42137be04aba.json
deleted file mode 100644
index f5faf9c4..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-5fd4255c-167c-4244-877a-42137be04aba.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "5fd4255c-167c-4244-877a-42137be04aba",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CpMHCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLbBQoRCg9icmFpbnRydXN0LWphdmESxQUKED0a/IwNBHpdcJDm5YBaF/ISCDV1yZx7Axy/Kg9DaGF0IENvbXBsZXRpb24wATnruA4pvH2kGEE5OTRVvH2kGEouChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxIQCg57InR5cGUiOiJsbG0ifUoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3RKVwoVYnJhaW50cnVzdC5pbnB1dF9qc29uEj4KPFt7ImNvbnRlbnQiOiJXaGF0IGlzIHRoZSBjYXBpdGFsIG9mIEZyYW5jZT8iLCJyb2xlIjoidXNlciJ9XUpOChJicmFpbnRydXN0Lm1ldHJpY3MSOAo2eyJjb21wbGV0aW9uX3Rva2VucyI6NywicHJvbXB0X3Rva2VucyI6MTQsInRva2VucyI6MjF9SqwBChNicmFpbnRydXN0Lm1ldGFkYXRhEpQBCpEBeyJwcm92aWRlciI6Im9wZW5haSIsInJlcXVlc3RfcGF0aCI6ImNoYXQvY29tcGxldGlvbnMiLCJtb2RlbCI6ImdwdC00by1taW5pIiwicmVxdWVzdF9iYXNlX3VyaSI6Imh0dHA6Ly9sb2NhbGhvc3Q6MzY4MDEiLCJyZXF1ZXN0X21ldGhvZCI6IlBPU1QifUq9AQoWYnJhaW50cnVzdC5vdXRwdXRfanNvbhKiAQqfAVt7ImluZGV4IjowLCJtZXNzYWdlIjp7InJvbGUiOiJhc3Npc3RhbnQiLCJjb250ZW50IjoiVGhlIGNhcGl0YWwgb2YgRnJhbmNlIGlzIFBhcmlzLiIsInJlZnVzYWwiOm51bGwsImFubm90YXRpb25zIjpbXX0sImxvZ3Byb2JzIjpudWxsLCJmaW5pc2hfcmVhc29uIjoic3RvcCJ9XXoAhQEBAQAA"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhN3OE7FoAMEF0Q=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c361-3d31762b17aa5132343969ed;Parent=585eeb26d660ccaf;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:06:41 GMT",
- "Via" : "1.1 2c24d855455b80190edd9e2dcdca3ee8.cloudfront.net (CloudFront), 1.1 ee5f8da78d4211a93c9dba8864a4067e.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c36100000000585754be43cfefae",
- "x-amzn-RequestId" : "ecea8885-9fab-49da-94c4-cad29524911d",
- "X-Amz-Cf-Id" : "SW5kR6Qwl8j1MjJh-DOSjlSX-COATqAjUlBYvLMVwrQxDe0fT3T5bg==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "5fd4255c-167c-4244-877a-42137be04aba",
- "persistent" : true,
- "insertionIndex" : 159
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-61e2fe04-2f31-43e5-9b63-b6313e610d09.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-61e2fe04-2f31-43e5-9b63-b6313e610d09.json
deleted file mode 100644
index 7ac9440b..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-61e2fe04-2f31-43e5-9b63-b6313e610d09.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "61e2fe04-2f31-43e5-9b63-b6313e610d09",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cqZZQHrcIAMEW_w=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69f40907-3d1fc9771bb6e7d618438817;Parent=30b1a3138ab78064;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Fri, 01 May 2026 01:59:35 GMT",
- "Via" : "1.1 d6022fdb6e8ea3c6fe76398e42003fcc.cloudfront.net (CloudFront), 1.1 566cc276dff9847158a5a9854be4df42.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69f40907000000004e277e1fd6cc5616",
- "x-amzn-RequestId" : "7ae9f9d9-4c88-4fb7-9ee4-364dd03eb573",
- "X-Amz-Cf-Id" : "8cvD0nq9BirOkpq2R3G0_YEhIlKjpxCFnrLoOA033Muq9zttzk-gVg==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "61e2fe04-2f31-43e5-9b63-b6313e610d09",
- "persistent" : true,
- "insertionIndex" : 238
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-64080a12-41b3-4a05-8f91-f6659445c060.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-64080a12-41b3-4a05-8f91-f6659445c060.json
deleted file mode 100644
index 05b28d25..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-64080a12-41b3-4a05-8f91-f6659445c060.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "64080a12-41b3-4a05-8f91-f6659445c060",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNWuEHcIAMEJFw=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c291-72783edc5117ad9d3409bd45;Parent=3156fb5ffc229b3e;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:03:13 GMT",
- "Via" : "1.1 8e6c2cf5874f5e4093136cc3de4d856a.cloudfront.net (CloudFront), 1.1 82fa7f20ab5a12301da8e01f9493e222.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c291000000006c44b03b576eecc8",
- "x-amzn-RequestId" : "da7f6538-c96f-4aa7-a8c9-9353291395a5",
- "X-Amz-Cf-Id" : "wtQngrUOiONEDPBmIKbBCDFyqIn4P2WI2nYPdNwxowJxadx8pLswtw==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "64080a12-41b3-4a05-8f91-f6659445c060",
- "persistent" : true,
- "insertionIndex" : 138
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-6e3bf0b3-a42c-4817-86ad-34b2a0629d66.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-6e3bf0b3-a42c-4817-86ad-34b2a0629d66.json
deleted file mode 100644
index d69a45f3..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-6e3bf0b3-a42c-4817-86ad-34b2a0629d66.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "6e3bf0b3-a42c-4817-86ad-34b2a0629d66",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CpMHCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLbBQoRCg9icmFpbnRydXN0LWphdmESxQUKEEldsgH2Gga6rZwpsF/crDYSCARmm7OXybCUKg9DaGF0IENvbXBsZXRpb24wAzkgp/4ytn2kGEHPv95Utn2kGEpXChVicmFpbnRydXN0LmlucHV0X2pzb24SPgo8W3sicm9sZSI6InVzZXIiLCJjb250ZW50IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/In1dSk4KEmJyYWludHJ1c3QubWV0cmljcxI4CjZ7ImNvbXBsZXRpb25fdG9rZW5zIjo3LCJwcm9tcHRfdG9rZW5zIjoxNCwidG9rZW5zIjoyMX1KLgoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSEAoOeyJ0eXBlIjoibGxtIn1KMgoRYnJhaW50cnVzdC5wYXJlbnQSHQobcHJvamVjdF9uYW1lOmphdmEtdW5pdC10ZXN0Sr0BChZicmFpbnRydXN0Lm91dHB1dF9qc29uEqIBCp8BW3siaW5kZXgiOjAsIm1lc3NhZ2UiOnsicm9sZSI6ImFzc2lzdGFudCIsImNvbnRlbnQiOiJUaGUgY2FwaXRhbCBvZiBGcmFuY2UgaXMgUGFyaXMuIiwicmVmdXNhbCI6bnVsbCwiYW5ub3RhdGlvbnMiOltdfSwibG9ncHJvYnMiOm51bGwsImZpbmlzaF9yZWFzb24iOiJzdG9wIn1dSqwBChNicmFpbnRydXN0Lm1ldGFkYXRhEpQBCpEBeyJwcm92aWRlciI6Im9wZW5haSIsInJlcXVlc3RfcGF0aCI6ImNoYXQvY29tcGxldGlvbnMiLCJtb2RlbCI6ImdwdC00by1taW5pIiwicmVxdWVzdF9iYXNlX3VyaSI6Imh0dHA6Ly9sb2NhbGhvc3Q6Mzc1MzEiLCJyZXF1ZXN0X21ldGhvZCI6IlBPU1QifXoAhQEBAQAA"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNzNF6qIAMEYpA=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c347-1744a1b523a6f84924b11e9a;Parent=62999f77862d39bc;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:06:15 GMT",
- "Via" : "1.1 b47176981720d8607d309e56e9510316.cloudfront.net (CloudFront), 1.1 87247d9a9b2f9e51b0c72b364948aefa.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c3470000000005e86ce7390aabfc",
- "x-amzn-RequestId" : "840a53ae-482e-4097-9eb2-07e81e5646a7",
- "X-Amz-Cf-Id" : "42ijB0NBOZsajIRYJM9rmHEI7VoJrl80qSr4E7qfmAG-Rku48cYZbg==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "6e3bf0b3-a42c-4817-86ad-34b2a0629d66",
- "persistent" : true,
- "insertionIndex" : 150
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-75a59469-2bf7-4a57-88e0-c57c985ff095.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-75a59469-2bf7-4a57-88e0-c57c985ff095.json
deleted file mode 100644
index f8d35eb5..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-75a59469-2bf7-4a57-88e0-c57c985ff095.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "75a59469-2bf7-4a57-88e0-c57c985ff095",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNbEGIKoAMENtw=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c2ac-543cbc3c4db0460f73587993;Parent=7f3e02157586dde2;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:03:41 GMT",
- "Via" : "1.1 7fcfc911845f681c235b0b3f32f3e1c6.cloudfront.net (CloudFront), 1.1 0eb43913f9caf453beb959a8a836a688.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c2ac00000000304c83830006c9a7",
- "x-amzn-RequestId" : "732acc11-bf6f-4f7e-a456-e8f7642cd7b6",
- "X-Amz-Cf-Id" : "LgVe1J4WttHPNNrntjUejLP_KztZtjWC54vi83Fin4qrwEXVfi0J1g==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "75a59469-2bf7-4a57-88e0-c57c985ff095",
- "persistent" : true,
- "insertionIndex" : 133
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-75dd8273-1f17-47fd-a992-66877387d37e.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-75dd8273-1f17-47fd-a992-66877387d37e.json
deleted file mode 100644
index a1f604b9..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-75dd8273-1f17-47fd-a992-66877387d37e.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "75dd8273-1f17-47fd-a992-66877387d37e",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CsEHCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjEtYmNiODkxZAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKJBgoYChZicmFpbnRydXN0LWF3cy1iZWRyb2NrEuwFChCy97QyFjPe8Eg2mLgJUP4IEgih7+cWMq5DnCoQYmVkcm9jay5jb252ZXJzZTABOdg79eUZ5qcYQTcCLgsa5qcYSoMBChVicmFpbnRydXN0LmlucHV0X2pzb24SagpoW3sicm9sZSI6InVzZXIiLCJjb250ZW50IjpbeyJ0ZXh0IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/IFJlcGx5IGluIG9uZSB3b3JkLiIsInR5cGUiOiJ0ZXh0In1dfV1KTgoSYnJhaW50cnVzdC5tZXRyaWNzEjgKNnsiY29tcGxldGlvbl90b2tlbnMiOjUsInByb21wdF90b2tlbnMiOjE5LCJ0b2tlbnMiOjI0fUoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3RKLgoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSEAoOeyJ0eXBlIjoibGxtIn1KXgoWYnJhaW50cnVzdC5vdXRwdXRfanNvbhJECkJbeyJjb250ZW50IjpbeyJ0ZXh0IjoiUGFyaXMuIiwidHlwZSI6InRleHQifV0sInJvbGUiOiJhc3Npc3RhbnQifV1KhQIKE2JyYWludHJ1c3QubWV0YWRhdGES7QEK6gF7ImVuZHBvaW50IjoiY29udmVyc2UiLCJwcm92aWRlciI6ImJlZHJvY2siLCJyZXF1ZXN0X3BhdGgiOiJtb2RlbC91cy5hbnRocm9waWMuY2xhdWRlLTMtaGFpa3UtMjAyNDAzMDctdjElM0EwL2NvbnZlcnNlIiwibW9kZWwiOiJ1cy5hbnRocm9waWMuY2xhdWRlLTMtaGFpa3UtMjAyNDAzMDctdjE6MCIsInJlcXVlc3RfYmFzZV91cmkiOiJodHRwOi8vbG9jYWxob3N0IiwicmVxdWVzdF9tZXRob2QiOiJQT1NUIn16AIUBAQEAAA=="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cFzmlHGYIAMET-Q=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69e56629-5cd1a8c0794a4f6b3eb47a9e;Parent=2ee2105957db22b5;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Sun, 19 Apr 2026 23:32:57 GMT",
- "Via" : "1.1 724581b48d733e53834b535d2a623034.cloudfront.net (CloudFront), 1.1 0df7f27a01014ab815259ca2d88193c6.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69e566290000000055572a49559b620a",
- "x-amzn-RequestId" : "adc86931-7fe8-499c-a5c4-f67bf1097ed5",
- "X-Amz-Cf-Id" : "stArdbVvbIxGJ8ZYc66r7k32hj9GsNWmOMhDR34ZohRixKkaVYDLbQ==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "75dd8273-1f17-47fd-a992-66877387d37e",
- "persistent" : true,
- "insertionIndex" : 163
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-775e27b5-8787-4981-93c4-edd300187bb4.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-775e27b5-8787-4981-93c4-edd300187bb4.json
deleted file mode 100644
index cb1a86b7..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-775e27b5-8787-4981-93c4-edd300187bb4.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "775e27b5-8787-4981-93c4-edd300187bb4",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "Cu4HCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjYtYzY3NjFlMgogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBK2BgoRCg9icmFpbnRydXN0LWphdmESoAYKEL7f4AoHt0wTGl+ERUygUfkSCMcmJFBX8CddKg9DaGF0IENvbXBsZXRpb24wATkYvxZPqMisGEH5Q/toqMisGEqRAQoVYnJhaW50cnVzdC5pbnB1dF9qc29uEngKdlt7ImNvbnRlbnQiOiJZb3UgYXJlIGEgaGVscGZ1bCBhc3Npc3RhbnQiLCJyb2xlIjoic3lzdGVtIn0seyJjb250ZW50IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/Iiwicm9sZSI6InVzZXIifV1KbwoSYnJhaW50cnVzdC5tZXRyaWNzElkKV3siY29tcGxldGlvbl90b2tlbnMiOjcsInByb21wdF90b2tlbnMiOjIzLCJ0b2tlbnMiOjMwLCJ0aW1lX3RvX2ZpcnN0X3Rva2VuIjowLjAwMTAwNTc1fUouChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxIQCg57InR5cGUiOiJsbG0ifUoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3RKvAEKFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SoQEKngFbeyJmaW5pc2hfcmVhc29uIjoic3RvcCIsImluZGV4IjowLCJsb2dwcm9icyI6bnVsbCwibWVzc2FnZSI6eyJjb250ZW50IjoiVGhlIGNhcGl0YWwgb2YgRnJhbmNlIGlzIFBhcmlzLiIsInJlZnVzYWwiOm51bGwsInJvbGUiOiJhc3Npc3RhbnQiLCJ0b29sX2NhbGxzIjpbXX19XUqsAQoTYnJhaW50cnVzdC5tZXRhZGF0YRKUAQqRAXsicHJvdmlkZXIiOiJvcGVuYWkiLCJyZXF1ZXN0X3BhdGgiOiJjaGF0L2NvbXBsZXRpb25zIiwibW9kZWwiOiJncHQtNG8tbWluaSIsInJlcXVlc3RfYmFzZV91cmkiOiJodHRwOi8vbG9jYWxob3N0OjYxNDI5IiwicmVxdWVzdF9tZXRob2QiOiJQT1NUIn16AIUBAQEAAA=="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "c6QifFidIAMEF7w=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SFO53-P8", "SFO53-P1" ],
- "X-Amzn-Trace-Id" : "Root=1-69fa6142-2d5c109c4f9423490ca92e05;Parent=197ed29d6363de32;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Tue, 05 May 2026 21:29:38 GMT",
- "Via" : "1.1 5cf315a7bafce190fcf84f55b9019bda.cloudfront.net (CloudFront), 1.1 ae36c784d97e7ce679dceb12ec90e722.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69fa61420000000022ba2aa82ecaaa3a",
- "x-amzn-RequestId" : "24b1b62e-d73c-4c8c-ad85-4957d5f41c0f",
- "X-Amz-Cf-Id" : "-Fge29U153EDMGDZ3a4cH1UBd7JvP7Grv5ylL-txcZovEFRNJaCTdg==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "775e27b5-8787-4981-93c4-edd300187bb4",
- "persistent" : true,
- "insertionIndex" : 249
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-7904ff97-3f35-4ee3-8c22-0e39324e29cb.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-7904ff97-3f35-4ee3-8c22-0e39324e29cb.json
deleted file mode 100644
index a557ffc4..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-7904ff97-3f35-4ee3-8c22-0e39324e29cb.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "7904ff97-3f35-4ee3-8c22-0e39324e29cb",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CoULCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLNCQoRCg9icmFpbnRydXN0LWphdmEStwkKEAe1zdrOenbv0HrFHnFrtUMSCN548FQqdUXxKhlhbnRocm9waWMubWVzc2FnZXMuY3JlYXRlMAE5h+WY5K99pBhBFq4FYrB9pBhKkQEKFWJyYWludHJ1c3QuaW5wdXRfanNvbhJ4CnZbeyJjb250ZW50IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/Iiwicm9sZSI6InVzZXIifSx7InJvbGUiOiJzeXN0ZW0iLCJjb250ZW50IjoiWW91IGFyZSBhIGhlbHBmdWwgYXNzaXN0YW50In1dSnEKEmJyYWludHJ1c3QubWV0cmljcxJbCll7ImNvbXBsZXRpb25fdG9rZW5zIjoxMCwicHJvbXB0X3Rva2VucyI6MTksInRva2VucyI6MjksInRpbWVfdG9fZmlyc3RfdG9rZW4iOjAuMDIwMzc4ODM5fUoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3RKLgoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSEAoOeyJ0eXBlIjoibGxtIn1K0wQKFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SuAQKtQR7ImlkIjoibXNnXzAxNFNnZzZIWFhBRTF0ZlVNS25aYjk0YiIsImNvbnRlbnQiOlt7ImNpdGF0aW9ucyI6bnVsbCwidGV4dCI6IlRoZSBjYXBpdGFsIG9mIEZyYW5jZSBpcyBQYXJpcy4iLCJ0eXBlIjoidGV4dCIsInZhbGlkIjp0cnVlfV0sIm1vZGVsIjoiY2xhdWRlLTMtaGFpa3UtMjAyNDAzMDciLCJyb2xlIjoiYXNzaXN0YW50Iiwic3RvcF9yZWFzb24iOiJlbmRfdHVybiIsInN0b3Bfc2VxdWVuY2UiOm51bGwsInR5cGUiOiJtZXNzYWdlIiwidXNhZ2UiOnsiY2FjaGVfY3JlYXRpb25faW5wdXRfdG9rZW5zIjowLCJjYWNoZV9yZWFkX2lucHV0X3Rva2VucyI6MCwiaW5wdXRfdG9rZW5zIjoxOSwib3V0cHV0X3Rva2VucyI6MTAsInNlcnZlcl90b29sX3VzZSI6bnVsbCwic2VydmljZV90aWVyIjoic3RhbmRhcmQiLCJ2YWxpZCI6dHJ1ZSwiaW5mZXJlbmNlX2dlbyI6Im5vdF9hdmFpbGFibGUiLCJjYWNoZV9jcmVhdGlvbiI6eyJlcGhlbWVyYWxfNW1faW5wdXRfdG9rZW5zIjowLCJlcGhlbWVyYWxfMWhfaW5wdXRfdG9rZW5zIjowfX0sInZhbGlkIjp0cnVlLCJzdG9wX2RldGFpbHMiOm51bGx9SqABChNicmFpbnRydXN0Lm1ldGFkYXRhEogBCoUBeyJwcm92aWRlciI6ImFudGhyb3BpYyIsInJlcXVlc3RfcGF0aCI6InYxL21lc3NhZ2VzIiwibW9kZWwiOiJjbGF1ZGUtMy1oYWlrdS0yMDI0MDMwNyIsInJlcXVlc3RfYmFzZV91cmkiOiIiLCJyZXF1ZXN0X21ldGhvZCI6IlBPU1QifXoAhQEBAQAA"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNvOG-tIAMEUvw=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c32d-4fd9af4f009f571d21fb5dc4;Parent=25e805301ee6122a;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:05:50 GMT",
- "Via" : "1.1 b7e07d6a19a4c8b2e410e9c1e173548c.cloudfront.net (CloudFront), 1.1 b669d9add7767f73665f1f8b7e8cd802.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c32d000000000d58fd31b3268fcc",
- "x-amzn-RequestId" : "48e131fb-5d50-4399-a281-f253ffcaebd5",
- "X-Amz-Cf-Id" : "xbGo2lkRZZcgcBAjHn-nAsNDvRbXLabmiIOhg9RzDvXeqvLltqytPw==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "7904ff97-3f35-4ee3-8c22-0e39324e29cb",
- "persistent" : true,
- "insertionIndex" : 145
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-7dedc996-befc-4b93-9540-376b1820eb72.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-7dedc996-befc-4b93-9540-376b1820eb72.json
deleted file mode 100644
index a16af0be..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-7dedc996-befc-4b93-9540-376b1820eb72.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "7dedc996-befc-4b93-9540-376b1820eb72",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CpQKCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLcCAoRCg9icmFpbnRydXN0LWphdmESxggKENJF7bavLqQ5lxRORIney38SCEq4c8OHIu7uKhlhbnRocm9waWMubWVzc2FnZXMuY3JlYXRlMAE5eddqm7F9pBhBMZNkz7F9pBhKkQEKFWJyYWludHJ1c3QuaW5wdXRfanNvbhJ4CnZbeyJjb250ZW50IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/Iiwicm9sZSI6InVzZXIifSx7InJvbGUiOiJzeXN0ZW0iLCJjb250ZW50IjoiWW91IGFyZSBhIGhlbHBmdWwgYXNzaXN0YW50In1dSk8KEmJyYWludHJ1c3QubWV0cmljcxI5Cjd7ImNvbXBsZXRpb25fdG9rZW5zIjoxMCwicHJvbXB0X3Rva2VucyI6MTksInRva2VucyI6Mjl9SjIKEWJyYWludHJ1c3QucGFyZW50Eh0KG3Byb2plY3RfbmFtZTpqYXZhLXVuaXQtdGVzdEouChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxIQCg57InR5cGUiOiJsbG0ifUqEBAoWYnJhaW50cnVzdC5vdXRwdXRfanNvbhLpAwrmA3sibW9kZWwiOiJjbGF1ZGUtMy1oYWlrdS0yMDI0MDMwNyIsImlkIjoibXNnXzAxREJIaWVxZThMaFFxdWdReUVBZHZYUiIsInR5cGUiOiJtZXNzYWdlIiwicm9sZSI6ImFzc2lzdGFudCIsImNvbnRlbnQiOlt7InR5cGUiOiJ0ZXh0IiwidGV4dCI6IlRoZSBjYXBpdGFsIG9mIEZyYW5jZSBpcyBQYXJpcy4ifV0sInN0b3BfcmVhc29uIjoiZW5kX3R1cm4iLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGwsInVzYWdlIjp7ImlucHV0X3Rva2VucyI6MTksImNhY2hlX2NyZWF0aW9uX2lucHV0X3Rva2VucyI6MCwiY2FjaGVfcmVhZF9pbnB1dF90b2tlbnMiOjAsImNhY2hlX2NyZWF0aW9uIjp7ImVwaGVtZXJhbF81bV9pbnB1dF90b2tlbnMiOjAsImVwaGVtZXJhbF8xaF9pbnB1dF90b2tlbnMiOjB9LCJvdXRwdXRfdG9rZW5zIjoxMCwic2VydmljZV90aWVyIjoic3RhbmRhcmQiLCJpbmZlcmVuY2VfZ2VvIjoibm90X2F2YWlsYWJsZSJ9fUqgAQoTYnJhaW50cnVzdC5tZXRhZGF0YRKIAQqFAXsicHJvdmlkZXIiOiJhbnRocm9waWMiLCJyZXF1ZXN0X3BhdGgiOiJ2MS9tZXNzYWdlcyIsIm1vZGVsIjoiY2xhdWRlLTMtaGFpa3UtMjAyNDAzMDciLCJyZXF1ZXN0X2Jhc2VfdXJpIjoiIiwicmVxdWVzdF9tZXRob2QiOiJQT1NUIn16AIUBAQEAAA=="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNwKFdlIAMEFtw=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c333-00f426cb2a25d3ad3974a5f2;Parent=4a86c1cb7d4ed6b4;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:05:56 GMT",
- "Via" : "1.1 a642518ef4d5fb78c3190de112922a38.cloudfront.net (CloudFront), 1.1 b3ccaedda78c63d5967b57382ceb4cbe.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c3330000000014e097c76999188b",
- "x-amzn-RequestId" : "daf443ba-3fa4-4c6d-ac35-2e14fd45dd5d",
- "X-Amz-Cf-Id" : "8-JdqKLPiJ27YCFi5g8kjCeE61KXTq3uQthKyaeCAjIdeU_9vtIYmQ==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "7dedc996-befc-4b93-9540-376b1820eb72",
- "persistent" : true,
- "insertionIndex" : 141
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-8d7d9804-3696-4f6d-b354-d6ea0213c1d3.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-8d7d9804-3696-4f6d-b354-d6ea0213c1d3.json
deleted file mode 100644
index aca68ad9..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-8d7d9804-3696-4f6d-b354-d6ea0213c1d3.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "8d7d9804-3696-4f6d-b354-d6ea0213c1d3",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CtUCCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKdAQoLCglteSB0cmFjZXISjQEKENDWlgZzpUfGuICJJCM92rASCPVKlpOhMFgMKg51bml0LXRlc3Qtcm9vdDABORByYEmIfaQYQdE/YUmIfaQYSjIKEWJyYWludHJ1c3QucGFyZW50Eh0KG3Byb2plY3RfbmFtZTpqYXZhLXVuaXQtdGVzdEoPCgl1bml0LXRlc3QSAhABegCFAQEBAAA="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNUSEodIAMEBMw=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c281-6ca82b966887099037409083;Parent=06fa00ebeb3ec721;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:02:57 GMT",
- "Via" : "1.1 b7e07d6a19a4c8b2e410e9c1e173548c.cloudfront.net (CloudFront), 1.1 dbfd9bcc806d4c322e72b461b2458112.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c281000000002b6ed03f910e6f2b",
- "x-amzn-RequestId" : "949749f2-104c-4fe9-8a35-b14bc4d407ea",
- "X-Amz-Cf-Id" : "0m0mYoaIwocvz3GpAMK7fEHzpjpMl5kKFOhB0fq3FcV4NEst52OVEA==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "8d7d9804-3696-4f6d-b354-d6ea0213c1d3",
- "persistent" : true,
- "insertionIndex" : 3
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-90e0003e-1382-47dc-a394-cec76f5217e3.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-90e0003e-1382-47dc-a394-cec76f5217e3.json
deleted file mode 100644
index 3eff557e..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-90e0003e-1382-47dc-a394-cec76f5217e3.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "90e0003e-1382-47dc-a394-cec76f5217e3",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cseFIFYboAMEjbA=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69f4dd53-194defe53ad8c696383ea8d2;Parent=4c1246be9be3daf8;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Fri, 01 May 2026 17:05:23 GMT",
- "Via" : "1.1 21c7c4234f218bb5110262cbbf01f870.cloudfront.net (CloudFront), 1.1 0df7f27a01014ab815259ca2d88193c6.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69f4dd53000000001af60319527ae280",
- "x-amzn-RequestId" : "d0f47664-3746-40d9-b560-ede1ddc66365",
- "X-Amz-Cf-Id" : "op7pQRDM1-b4bFBMiYWHe5PdIivjcE4zQKForBqG09apkLqypJboPw==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "90e0003e-1382-47dc-a394-cec76f5217e3",
- "persistent" : true,
- "insertionIndex" : 246
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-9294f422-5552-4bdd-8d60-9a88fb07ae29.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-9294f422-5552-4bdd-8d60-9a88fb07ae29.json
deleted file mode 100644
index 261a1337..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-9294f422-5552-4bdd-8d60-9a88fb07ae29.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "9294f422-5552-4bdd-8d60-9a88fb07ae29",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cqZfKGCxIAMEmYw=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69f4092d-264a5082478230ac4ca2a86d;Parent=389ea40374e1c39a;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Fri, 01 May 2026 02:00:13 GMT",
- "Via" : "1.1 4c9457912580c6114eec78b8fa604a20.cloudfront.net (CloudFront), 1.1 7605973575a3551426b82751020317de.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69f4092d000000002fbeda8ee12dba14",
- "x-amzn-RequestId" : "a1690264-7aad-4df3-be78-1eab889ea2c6",
- "X-Amz-Cf-Id" : "yw5o6mwxvPALrpZVrIWVssFzDuGArBsaQ4WbWzLC2k5LHZFAtAT99g==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "9294f422-5552-4bdd-8d60-9a88fb07ae29",
- "persistent" : true,
- "insertionIndex" : 234
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-96059fcb-90ff-4b64-99ee-0cd48bbde38a.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-96059fcb-90ff-4b64-99ee-0cd48bbde38a.json
deleted file mode 100644
index 7c593ceb..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-96059fcb-90ff-4b64-99ee-0cd48bbde38a.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "96059fcb-90ff-4b64-99ee-0cd48bbde38a",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "Cu8JCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBK3CAoRCg9icmFpbnRydXN0LWphdmESoQgKEAAHtp8EhSLrwyy2GZCWsVMSCODwaV/h0O8PKhlhbnRocm9waWMubWVzc2FnZXMuY3JlYXRlMAE5aMoVcrx9pBhByYCvobx9pBhKLgoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSEAoOeyJ0eXBlIjoibGxtIn1KMgoRYnJhaW50cnVzdC5wYXJlbnQSHQobcHJvamVjdF9uYW1lOmphdmEtdW5pdC10ZXN0SlcKFWJyYWludHJ1c3QuaW5wdXRfanNvbhI+CjxbeyJjb250ZW50IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/Iiwicm9sZSI6InVzZXIifV1KTwoSYnJhaW50cnVzdC5tZXRyaWNzEjkKN3siY29tcGxldGlvbl90b2tlbnMiOjEwLCJwcm9tcHRfdG9rZW5zIjoxNCwidG9rZW5zIjoyNH1KtgEKE2JyYWludHJ1c3QubWV0YWRhdGESngEKmwF7InByb3ZpZGVyIjoiYW50aHJvcGljIiwicmVxdWVzdF9wYXRoIjoidjEvbWVzc2FnZXMiLCJtb2RlbCI6ImNsYXVkZS0zLWhhaWt1LTIwMjQwMzA3IiwicmVxdWVzdF9iYXNlX3VyaSI6Imh0dHA6Ly9sb2NhbGhvc3Q6NDAyNzEiLCJyZXF1ZXN0X21ldGhvZCI6IlBPU1QifUqEBAoWYnJhaW50cnVzdC5vdXRwdXRfanNvbhLpAwrmA3sibW9kZWwiOiJjbGF1ZGUtMy1oYWlrdS0yMDI0MDMwNyIsImlkIjoibXNnXzAxNWdnRTZETVdEbjR4UUNkVmNXUGI0OSIsInR5cGUiOiJtZXNzYWdlIiwicm9sZSI6ImFzc2lzdGFudCIsImNvbnRlbnQiOlt7InR5cGUiOiJ0ZXh0IiwidGV4dCI6IlRoZSBjYXBpdGFsIG9mIEZyYW5jZSBpcyBQYXJpcy4ifV0sInN0b3BfcmVhc29uIjoiZW5kX3R1cm4iLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGwsInVzYWdlIjp7ImlucHV0X3Rva2VucyI6MTQsImNhY2hlX2NyZWF0aW9uX2lucHV0X3Rva2VucyI6MCwiY2FjaGVfcmVhZF9pbnB1dF90b2tlbnMiOjAsImNhY2hlX2NyZWF0aW9uIjp7ImVwaGVtZXJhbF81bV9pbnB1dF90b2tlbnMiOjAsImVwaGVtZXJhbF8xaF9pbnB1dF90b2tlbnMiOjB9LCJvdXRwdXRfdG9rZW5zIjoxMCwic2VydmljZV90aWVyIjoic3RhbmRhcmQiLCJpbmZlcmVuY2VfZ2VvIjoibm90X2F2YWlsYWJsZSJ9fXoAhQEBAQAA"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhN3aE1CIAMEdlQ=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c362-3b2ce3fa2874ab1171f0eb47;Parent=4ec48b303c3c4e20;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:06:42 GMT",
- "Via" : "1.1 d08613e1dd8ad614e47875ae31a8af20.cloudfront.net (CloudFront), 1.1 0df7f27a01014ab815259ca2d88193c6.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c362000000001e2532db09154f34",
- "x-amzn-RequestId" : "993e7d2a-4182-4658-ba70-6ea51501da4d",
- "X-Amz-Cf-Id" : "cZZYk4VTQ7oTH3t8-jNLtxW0AvXWIFDyPlatbYT11TZKThrAez9Qxw==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "96059fcb-90ff-4b64-99ee-0cd48bbde38a",
- "persistent" : true,
- "insertionIndex" : 158
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-97f73962-c2ec-4c5b-9d6d-d6b18be33c71.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-97f73962-c2ec-4c5b-9d6d-d6b18be33c71.json
deleted file mode 100644
index 461cabc7..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-97f73962-c2ec-4c5b-9d6d-d6b18be33c71.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "97f73962-c2ec-4c5b-9d6d-d6b18be33c71",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cseE5HTOoAMEVvg=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69f4dd52-75e08f477e28e3e26be1db0f;Parent=38904f26485a8cc6;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Fri, 01 May 2026 17:05:22 GMT",
- "Via" : "1.1 b7d7903ada432685f0e90f0ca261d864.cloudfront.net (CloudFront), 1.1 0df7f27a01014ab815259ca2d88193c6.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69f4dd52000000002eee535e020d29df",
- "x-amzn-RequestId" : "8217c8d4-7e51-4984-8b66-a438a812b4cf",
- "X-Amz-Cf-Id" : "42X5huKjnCjai2cFQ-Tg9I94uo1Ye-abilhf3LbIr_6nd_Sg0ehOAQ==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "97f73962-c2ec-4c5b-9d6d-d6b18be33c71",
- "persistent" : true,
- "insertionIndex" : 247
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-98d8a3f8-bee0-4a83-818d-889dab9996ef.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-98d8a3f8-bee0-4a83-818d-889dab9996ef.json
deleted file mode 100644
index 38c59bdc..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-98d8a3f8-bee0-4a83-818d-889dab9996ef.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "98d8a3f8-bee0-4a83-818d-889dab9996ef",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cseF9ETVoAMEByA=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69f4dd58-045ed44a01ead96857b7e4bb;Parent=7d8907d03a95a71d;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Fri, 01 May 2026 17:05:29 GMT",
- "Via" : "1.1 2be627c4e85d6d9d9e32a7523e1b67ee.cloudfront.net (CloudFront), 1.1 ee5f8da78d4211a93c9dba8864a4067e.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69f4dd58000000004f40388e25f54801",
- "x-amzn-RequestId" : "31f744f6-b574-43e9-9196-86ec5fe188c9",
- "X-Amz-Cf-Id" : "7Wv1z-ND0XXD5TP71OAjWDjIkoZUI2wp1jko2WFFFY4jvX6P9dNA1w==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "98d8a3f8-bee0-4a83-818d-889dab9996ef",
- "persistent" : true,
- "insertionIndex" : 244
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-99102b67-0a22-402d-8c30-2c5a73935505.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-99102b67-0a22-402d-8c30-2c5a73935505.json
deleted file mode 100644
index 2f72809f..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-99102b67-0a22-402d-8c30-2c5a73935505.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "99102b67-0a22-402d-8c30-2c5a73935505",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CuACCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKoAQoWChRzb21lLWluc3RydW1lbnRhdGlvbhKNAQoQNKJlzZLfSiTtI66asI5K/hIIMMZYyhgk/7IqDnVuaXQtdGVzdC1yb290MAE5MFGYL4h9pBhB9HqZL4h9pBhKMgoRYnJhaW50cnVzdC5wYXJlbnQSHQobcHJvamVjdF9uYW1lOmphdmEtdW5pdC10ZXN0Sg8KCXVuaXQtdGVzdBICEAF6AIUBAQEAAA=="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNUOEGPoAMEa0A=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c281-07c447ae5286d7ac02f4648c;Parent=635d09b2b940f1b3;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:02:57 GMT",
- "Via" : "1.1 6281593da0ade6742b2f405f2b9ea0ba.cloudfront.net (CloudFront), 1.1 e82f2bd1d85893fad1abb144337e7368.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c281000000004d2afcbee707d639",
- "x-amzn-RequestId" : "0c3ea751-0e30-4f41-8a97-4f784f309000",
- "X-Amz-Cf-Id" : "yPqqOf8cIMTdkCy_NyVe77zkL5O2d4ldXMN9s7n5GdkfTLpu96m9RQ==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "99102b67-0a22-402d-8c30-2c5a73935505",
- "persistent" : true,
- "insertionIndex" : 4
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-99b58611-0146-4ad1-b73e-bcccb277fe9d.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-99b58611-0146-4ad1-b73e-bcccb277fe9d.json
deleted file mode 100644
index bf8e275c..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-99b58611-0146-4ad1-b73e-bcccb277fe9d.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "99b58611-0146-4ad1-b73e-bcccb277fe9d",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "Co8ICrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjYtYzY3NjFlMgogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLXBgoRCg9icmFpbnRydXN0LWphdmESwQYKEMPm5lru/LMvN1yG04PPTO0SCEYll3pobquBKglyZXNwb25zZXMwATmoZ5jMp8isGEE7AyH8p8isGEpXChVicmFpbnRydXN0LmlucHV0X2pzb24SPgo8W3siY29udGVudCI6IldoYXQgaXMgdGhlIGNhcGl0YWwgb2YgRnJhbmNlPyIsInJvbGUiOiJ1c2VyIn1dSpABChJicmFpbnRydXN0Lm1ldHJpY3MSegp4eyJjb21wbGV0aW9uX3Rva2VucyI6OCwicHJvbXB0X3Rva2VucyI6MjMsInRva2VucyI6MzEsImNvbXBsZXRpb25fcmVhc29uaW5nX3Rva2VucyI6MCwidGltZV90b19maXJzdF90b2tlbiI6MC4wMDE2MTQxMjV9Si4KGmJyYWludHJ1c3Quc3Bhbl9hdHRyaWJ1dGVzEhAKDnsidHlwZSI6ImxsbSJ9SjIKEWJyYWludHJ1c3QucGFyZW50Eh0KG3Byb2plY3RfbmFtZTpqYXZhLXVuaXQtdGVzdEqDAgoWYnJhaW50cnVzdC5vdXRwdXRfanNvbhLoAQrlAVt7ImlkIjoibXNnXzBhZmVkNGZjYjA1MGIwZjMwMDY5ZmE2MTQwNjg1ODgxOTRhYmU3ZjE1MmE4ZTVkNmYyIiwiY29udGVudCI6W3siYW5ub3RhdGlvbnMiOltdLCJ0ZXh0IjoiVGhlIGNhcGl0YWwgb2YgRnJhbmNlIGlzIFBhcmlzLiIsInR5cGUiOiJvdXRwdXRfdGV4dCIsImxvZ3Byb2JzIjpbXX1dLCJyb2xlIjoiYXNzaXN0YW50Iiwic3RhdHVzIjoiY29tcGxldGVkIiwidHlwZSI6Im1lc3NhZ2UifV1KpQEKE2JyYWludHJ1c3QubWV0YWRhdGESjQEKigF7InByb3ZpZGVyIjoib3BlbmFpIiwicmVxdWVzdF9wYXRoIjoicmVzcG9uc2VzIiwibW9kZWwiOiJncHQtNG8tbWluaSIsInJlcXVlc3RfYmFzZV91cmkiOiJodHRwOi8vbG9jYWxob3N0OjYxNDI5IiwicmVxdWVzdF9tZXRob2QiOiJQT1NUIn16AIUBAQEAAA=="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "c6QiLG_JoAMEquA=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SFO53-P8", "SFO53-P1" ],
- "X-Amzn-Trace-Id" : "Root=1-69fa6140-5655cfb14a4e2e320eeb5deb;Parent=0aac73529b3346cd;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Tue, 05 May 2026 21:29:36 GMT",
- "Via" : "1.1 dcd6c7d5f9e83c64e0ef0f23f0704dfa.cloudfront.net (CloudFront), 1.1 fdfef4416a2144ecb1660f70dad57e94.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69fa6140000000002af2bcb4d6da84fe",
- "x-amzn-RequestId" : "96eef02e-d8fd-4172-97d2-14c433db5239",
- "X-Amz-Cf-Id" : "jDLSMWZCCcxqLFEWDGhUM48mAEXJKFEmtrU1cQP6aIUpx_iZpUO-sA==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "99b58611-0146-4ad1-b73e-bcccb277fe9d",
- "persistent" : true,
- "insertionIndex" : 251
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-9a40ff66-614a-4fa7-818c-6d70671e1542.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-9a40ff66-614a-4fa7-818c-6d70671e1542.json
deleted file mode 100644
index 558fcf83..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-9a40ff66-614a-4fa7-818c-6d70671e1542.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "9a40ff66-614a-4fa7-818c-6d70671e1542",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNOeEdaoAMEHXg=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c25c-3a55db1571208d352a188eff;Parent=02f1f72442269833;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:02:20 GMT",
- "Via" : "1.1 8e6c2cf5874f5e4093136cc3de4d856a.cloudfront.net (CloudFront), 1.1 dbfd9bcc806d4c322e72b461b2458112.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c25c000000001b1e536383f8b081",
- "x-amzn-RequestId" : "746fdf8c-87e1-45f5-85ec-e46cf4fb7377",
- "X-Amz-Cf-Id" : "fNIvflqZfB4l7nXBn90MFYJlGqzi2an_eKJUOiQnOGlOFoHN8MbM4Q==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "9a40ff66-614a-4fa7-818c-6d70671e1542",
- "persistent" : true,
- "insertionIndex" : 90
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-9d6140bf-20ba-46d9-bf52-04252f2cfeb8.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-9d6140bf-20ba-46d9-bf52-04252f2cfeb8.json
deleted file mode 100644
index 8802589e..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-9d6140bf-20ba-46d9-bf52-04252f2cfeb8.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "9d6140bf-20ba-46d9-bf52-04252f2cfeb8",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cseGOFGiIAMEdXw=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69f4dd5a-73d0b6ff3bc2504676decda9;Parent=5cb2fd591711c13c;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Fri, 01 May 2026 17:05:30 GMT",
- "Via" : "1.1 d118b2ea8414d381f46f91331ab67f02.cloudfront.net (CloudFront), 1.1 ee5f8da78d4211a93c9dba8864a4067e.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69f4dd5a000000002d951f3871f5cdca",
- "x-amzn-RequestId" : "174bb784-1138-4cf0-80aa-33472e82b69c",
- "X-Amz-Cf-Id" : "U3iYZEMDnN6WkK8otECcOR_2wEVX5SzlnUtXDSkmsIoe6W1KECKQVQ==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "9d6140bf-20ba-46d9-bf52-04252f2cfeb8",
- "persistent" : true,
- "insertionIndex" : 243
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-a0c8a84a-0939-416c-b7d1-4fced391f690.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-a0c8a84a-0939-416c-b7d1-4fced391f690.json
deleted file mode 100644
index 303a7a5b..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-a0c8a84a-0939-416c-b7d1-4fced391f690.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "a0c8a84a-0939-416c-b7d1-4fced391f690",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CugJCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKwCAoRCg9icmFpbnRydXN0LWphdmESmggKEIMv0zUWFqrz2lzOhvrCNMwSCCHeDHfoIDvQKhBnZW5lcmF0ZV9jb250ZW50MAM5oW2Y6bN9pBhBqdeTELR9pBhKdQoTYnJhaW50cnVzdC5tZXRhZGF0YRJeClx7InByb3ZpZGVyIjoiZ2VtaW5pIiwidGVtcGVyYXR1cmUiOjAuMCwibW9kZWwiOiJnZW1pbmktMi4wLWZsYXNoLWxpdGUiLCJtYXhPdXRwdXRUb2tlbnMiOjUwfUrdAwoWYnJhaW50cnVzdC5vdXRwdXRfanNvbhLCAwq/A3siY2FuZGlkYXRlcyI6W3siY29udGVudCI6eyJwYXJ0cyI6W3sidGV4dCI6IlRoZSBjYXBpdGFsIG9mIEZyYW5jZSBpcyAqKlBhcmlzKiouXG4ifV0sInJvbGUiOiJtb2RlbCJ9LCJmaW5pc2hSZWFzb24iOiJTVE9QIiwiYXZnTG9ncHJvYnMiOi0wLjAwNjQ1MDQ2NDMyODEzMDA4Nn1dLCJ1c2FnZU1ldGFkYXRhIjp7InByb21wdFRva2VuQ291bnQiOjcsImNhbmRpZGF0ZXNUb2tlbkNvdW50Ijo5LCJ0b3RhbFRva2VuQ291bnQiOjE2LCJwcm9tcHRUb2tlbnNEZXRhaWxzIjpbeyJtb2RhbGl0eSI6IlRFWFQiLCJ0b2tlbkNvdW50Ijo3fV0sImNhbmRpZGF0ZXNUb2tlbnNEZXRhaWxzIjpbeyJtb2RhbGl0eSI6IlRFWFQiLCJ0b2tlbkNvdW50Ijo5fV19LCJtb2RlbFZlcnNpb24iOiJnZW1pbmktMi4wLWZsYXNoLWxpdGUiLCJyZXNwb25zZUlkIjoiUE1QV2FjV2VPcXI0cXRzUHlMTGE0UVEifUoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3RKLgoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSEAoOeyJ0eXBlIjoibGxtIn1KwQEKFWJyYWludHJ1c3QuaW5wdXRfanNvbhKnAQqkAXsiY29udGVudHMiOlt7InBhcnRzIjpbeyJ0ZXh0IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/In1dLCJyb2xlIjoidXNlciJ9XSwibW9kZWwiOiJnZW1pbmktMi4wLWZsYXNoLWxpdGUiLCJjb25maWciOnsidGVtcGVyYXR1cmUiOjAuMCwibWF4T3V0cHV0VG9rZW5zIjo1MH19Sk0KEmJyYWludHJ1c3QubWV0cmljcxI3CjV7ImNvbXBsZXRpb25fdG9rZW5zIjo5LCJwcm9tcHRfdG9rZW5zIjo3LCJ0b2tlbnMiOjE2fXoCGAGFAQEBAAA="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNxqEDuoAMEFzg=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c33d-6fddc6c6587a96682e97a20a;Parent=76074d0f0a5b35f3;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:06:05 GMT",
- "Via" : "1.1 20b3731a0ef4aba3db1fcd63c3ef2b2a.cloudfront.net (CloudFront), 1.1 73b0c4a85645a8031ba157e0b3e28ffc.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c33d00000000459bd88d710b02ce",
- "x-amzn-RequestId" : "fcb4e08c-c06b-4e70-b397-bbcd8e05bf0c",
- "X-Amz-Cf-Id" : "YKIfhR__EIl1lBAyWEgEn4NghxvQ8MtFarZEy-y6v06fFmlUw7lrdQ==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "a0c8a84a-0939-416c-b7d1-4fced391f690",
- "persistent" : true,
- "insertionIndex" : 146
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-a763f8ff-ac48-42d2-ad49-0f4204d96615.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-a763f8ff-ac48-42d2-ad49-0f4204d96615.json
deleted file mode 100644
index e9bfef73..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-a763f8ff-ac48-42d2-ad49-0f4204d96615.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "a763f8ff-ac48-42d2-ad49-0f4204d96615",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNOTFwYIAMENtw=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c25b-58cbd56549527e4735a65671;Parent=580340944e5606a6;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:02:19 GMT",
- "Via" : "1.1 d08613e1dd8ad614e47875ae31a8af20.cloudfront.net (CloudFront), 1.1 b669d9add7767f73665f1f8b7e8cd802.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c25b000000000fca400db84bc6b0",
- "x-amzn-RequestId" : "8c66959a-3fab-4eeb-a6ec-8659ab4e12b0",
- "X-Amz-Cf-Id" : "EryyAUAHp5cTAcZfgfVscJSQwHzWO0407O3myMzFWA6aDq2q8D-Z9g==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "a763f8ff-ac48-42d2-ad49-0f4204d96615",
- "persistent" : true,
- "insertionIndex" : 93
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-aa178f53-938e-44fa-81e3-865b0df28598.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-aa178f53-938e-44fa-81e3-865b0df28598.json
deleted file mode 100644
index 039c47b3..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-aa178f53-938e-44fa-81e3-865b0df28598.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "aa178f53-938e-44fa-81e3-865b0df28598",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNOGEgqoAMEmpQ=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c259-3e033f8f1385968d33884392;Parent=533f119eec43433e;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:02:18 GMT",
- "Via" : "1.1 940972e9e344075576fe20d5db482122.cloudfront.net (CloudFront), 1.1 4ac8d091dce10e726cfc5404bfed72b8.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c25900000000614135ab03a951bd",
- "x-amzn-RequestId" : "6314f439-c426-489c-92d7-4ed9c5c5102e",
- "X-Amz-Cf-Id" : "9uEejdd866vuFDC3D4JCe--0qqX78PIafNwr65Xb07DToJjWzE9w7w==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "aa178f53-938e-44fa-81e3-865b0df28598",
- "persistent" : true,
- "insertionIndex" : 95
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-ae6954af-acc7-45f0-a532-5f0ba2033d07.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-ae6954af-acc7-45f0-a532-5f0ba2033d07.json
deleted file mode 100644
index 9cbeb37c..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-ae6954af-acc7-45f0-a532-5f0ba2033d07.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "ae6954af-acc7-45f0-a532-5f0ba2033d07",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CuMhCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKeAQoFCgNidHgSlAEKEHSb8ZexM37o9Kk5zZlrDJcSCBlfZXMF0rt6KglyZWFzb25pbmcwATk75vd4iX2kGEEPvlZXj32kGEoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3RKGwoGY2xpZW50EhEKD3NwcmluZ2FpLW9wZW5haXoAhQEBAQAAEoofChEKD2JyYWludHJ1c3QtamF2YRL0HgoQdJvxl7Ezfuj0qTnNmWsMlxIImutqUKeKCd0iCBlfZXMF0rt6KglyZXNwb25zZXMwATnBque2jH2kGEFNgDVWj32kGEouChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxIQCg57InR5cGUiOiJsbG0ifUoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3RKmw4KFWJyYWludHJ1c3QuaW5wdXRfanNvbhKBDgr+DVt7InJvbGUiOiJ1c2VyIiwiY29udGVudCI6Ikxvb2sgYXQgdGhpcyBzZXF1ZW5jZTogMiwgNiwgMTIsIDIwLCAzMC4gV2hhdCBpcyB0aGUgcGF0dGVybiBhbmQgd2hhdCB3b3VsZCBiZSB0aGUgZm9ybXVsYSBmb3IgdGhlIG50aCB0ZXJtP1xuIn0seyJpZCI6InJzXzA1N2U2N2I4ZjZiYzViZWMwMDY5ZDZjMjg4MzQ4ODgxOTY4MDk3ZjcyYzQ1OGI0YjZhIiwic3VtbWFyeSI6W3sidGV4dCI6IioqSWRlbnRpZnlpbmcgdGhlIHNlcXVlbmNlIHBhdHRlcm4qKlxuXG5UaGUgdXNlciBoYXMgc2hhcmVkIGEgc2VxdWVuY2U6IDIsIDYsIDEyLCAyMCwgMzAuIEnigJltIG5vdGljaW5nIHRoaXMgZm9sbG93cyB0aGUgcGF0dGVybiBvZiBuKG4rMSkuIEJhc2ljYWxseSwgZm9yIG49MSB0byA1LCBJIGhhdmUgMSoyPTIsIDIqMz02LCBhbmQgc28gb24uIFNvLCB0aGUgbnRoIHRlcm0gY2FuIGJlIGV4cHJlc3NlZCBhcyBUX24gPSBuKG4rMSkgb3Igbl4yICsgbi4gVGhlc2UgbnVtYmVycyBhcmUgcHJvbmljIG9yIG9ibG9uZyBudW1iZXJzIGFzIHdlbGwuIEkgY2FuIGFsc28gc2VlIHRoYXQgdGhleSBhbGlnbiB3aXRoIHRyaWFuZ3VsYXIgbnVtYmVycyBtdWx0aXBsaWVkIGJ5IDIuIFVsdGltYXRlbHksIEkgdGhpbmsgdGhlIGZvcm11bGEgaXMgc2ltcGx5IGFfbiA9IG4obisxKS4iLCJ0eXBlIjoic3VtbWFyeV90ZXh0In0seyJ0ZXh0IjoiKipEZWZpbmluZyB0aGUgcHJvbmljIG51bWJlcnMqKlxuXG5TbyBzdGFydGluZyBmcm9tIG7iiaUxLCBJIHNlZSB0aGF0IHRoZSBudGggdGVybSBjYW4gYmUgZXhwcmVzc2VkIGFzIFRfbiA9IG4obisxKSwgaW5kaWNhdGluZyB0aGF0IHRoZXNlIG51bWJlcnMgYXJlIHByb25pYyBudW1iZXJzLCB3aGljaCBhcmUgcHJvZHVjdHMgb2YgdHdvIGNvbnNlY3V0aXZlIGludGVnZXJzLiBUaGUgZGlmZmVyZW5jZXMgYmV0d2VlbiB0aGUgdGVybXMgaW5jcmVhc2UgYnkgMiBlYWNoIHRpbWUgKDQsIDYsIDgsIDEwKSwgY29uZmlybWluZyBpdCdzIGEgcXVhZHJhdGljIHBhdHRlcm4uIEnigJl2ZSBkZXJpdmVkIHRoYXQgYV9uID0gbl4yICsgbiBmaXRzIHRoaXMgc2VxdWVuY2UuIElmIHN0YXJ0aW5nIGF0IG49MCwgdGhlIGZvcm11bGEgYWRqdXN0cyB0byBhX24gPSAobisxKShuKzIpLiBTbywgYV9uID0gbihuKzEpIGlzIGEgc3RyYWlnaHRmb3J3YXJkIGFuc3dlciEiLCJ0eXBlIjoic3VtbWFyeV90ZXh0In1dLCJ0eXBlIjoicmVhc29uaW5nIn0seyJpZCI6Im1zZ18wNTdlNjdiOGY2YmM1YmVjMDA2OWQ2YzI5M2FjZWM4MTk2OTFkNWIzYzc5OTE1OWRhZCIsImNvbnRlbnQiOlt7ImFubm90YXRpb25zIjpbXSwidGV4dCI6IlRoZSB0ZXJtcyBhcmUgIFxuIDIgPSAxwrcyICBcbiA2ID0gMsK3MyAgXG4xMiA9IDPCtzQgIFxuMjAgPSA0wrc1ICBcbjMwID0gNcK3NiAgXG5cbkluIG90aGVyIHdvcmRzLCB0aGUgbi10aCB0ZXJtIGlzIHRoZSBwcm9kdWN0IG9mIHR3byBjb25zZWN1dGl2ZSBpbnRlZ2Vycy4gIEVxdWl2YWxlbnRseVxuXG7igIJh4oKZID0gbihuICsgMSkgPSBuwrIgKyBuLCDigIJmb3IgbiA9IDEsIDIsIDMsIOKApiIsInR5cGUiOiJvdXRwdXRfdGV4dCIsImxvZ3Byb2JzIjpbXX1dLCJyb2xlIjoiYXNzaXN0YW50Iiwic3RhdHVzIjoiY29tcGxldGVkIiwidHlwZSI6Im1lc3NhZ2UifSx7InJvbGUiOiJ1c2VyIiwiY29udGVudCI6IlVzaW5nIHRoZSBwYXR0ZXJuIHlvdSBkaXNjb3ZlcmVkLCB3aGF0IHdvdWxkIGJlIHRoZSAxMHRoIHRlcm0/IEFuZCBjYW4geW91IGZpbmQgdGhlIHN1bSBvZiB0aGUgZmlyc3QgMTAgdGVybXM/In1dSnQKEmJyYWludHJ1c3QubWV0cmljcxJeClx7ImNvbXBsZXRpb25fdG9rZW5zIjo3MTUsInByb21wdF90b2tlbnMiOjE3MywidG9rZW5zIjo4ODgsImNvbXBsZXRpb25fcmVhc29uaW5nX3Rva2VucyI6NTEyfUqhAQoTYnJhaW50cnVzdC5tZXRhZGF0YRKJAQqGAXsicHJvdmlkZXIiOiJvcGVuYWkiLCJyZXF1ZXN0X3BhdGgiOiJyZXNwb25zZXMiLCJtb2RlbCI6Im80LW1pbmkiLCJyZXF1ZXN0X2Jhc2VfdXJpIjoiaHR0cDovL2xvY2FsaG9zdDo0MTUzMyIsInJlcXVlc3RfbWV0aG9kIjoiUE9TVCJ9SogNChZicmFpbnRydXN0Lm91dHB1dF9qc29uEu0MCuoMW3siaWQiOiJyc18wNTdlNjdiOGY2YmM1YmVjMDA2OWQ2YzI5NGRiMDg4MTk2OTBmZmZiMmE1OTBmMTVkZSIsInR5cGUiOiJyZWFzb25pbmciLCJzdW1tYXJ5IjpbeyJ0eXBlIjoic3VtbWFyeV90ZXh0IiwidGV4dCI6IioqQ2FsY3VsYXRpbmcgc3VtIGZvcm11bGFzKipcblxuVGhlIHVzZXIgaGFzIGEgZm9ybXVsYSBcXCggYV9uID0gbihuKzEpIFxcKSBhbmQgaXMgbG9va2luZyB0byBmaW5kIFxcKCBhX3sxMH0gXFwpLCB3aGljaCBpcyBcXCggMTAgXFx0aW1lcyAxMSA9IDExMCBcXCkuIE5leHQsIEkgbmVlZCB0byBjb21wdXRlIFxcKCBTX3sxMH0gPSBcXHN1bV97bj0xfV57MTB9IG4obisxKSBcXCkuIFRoaXMgc2ltcGxpZmllcyB0byBmaW5kaW5nIHRoZSBzdW1zIG9mIFxcKCBuXjIgXFwpIGFuZCBcXCggbiBcXCkuIFxuXG5BZnRlciBjYWxjdWxhdGluZywgSSBmaW5kIHRoYXQgXFwoIFNfezEwfSA9IDQ0MCBcXCkuIFRoZSBkZXJpdmVkIGdlbmVyYWwgZm9ybXVsYSBmb3IgdGhpcyBzdW0gaXMgXFwoIFxcc3VtX3trPTF9XntufSBrKGsrMSkgPSBcXGZyYWN7bihuKzEpKG4rMil9ezN9IFxcKS4gU28sIHRoZSBhbnN3ZXJzIGFyZSBcXCggYV97MTB9ID0gMTEwIFxcKSBhbmQgdGhlIHN1bSBlcXVhbHMgNDQwLiJ9LHsidHlwZSI6InN1bW1hcnlfdGV4dCIsInRleHQiOiIqKlN1bW1hcml6aW5nIHZhbHVlcyBhbmQgZm9ybXVsYXMqKlxuXG5JIGNhbiBwcm92aWRlIGNsZWFyIGFuc3dlcnMgbm93OiB0aGUgdGVybSBcXCggYV97MTB9ID0gMTAgXFx0aW1lcyAxMSA9IDExMCBcXCkuIE5leHQsIHRvIGZpbmQgdGhlIHN1bSBcXCggU197MTB9ID0gXFxzdW1fe249MX1eezEwfSBuKG4rMSkgXFwpLCBJIGNhbiB1c2UgdGhlIGZvcm11bGEgXFwoIFNfbiA9IFxcZnJhY3tuKG4rMSkobisyKX17M30gXFwpLCB3aGljaCBnaXZlcyBtZSBcXCggXFxmcmFjezEwIFxcdGltZXMgMTEgXFx0aW1lcyAxMn17M30gPSA0NDAgXFwpLiBTbywgdGhlIHJlc3VsdHMgYXJlIFxcKCBhX3sxMH0gPSAxMTAgXFwpIGFuZCBcXCggU197MTB9ID0gNDQwIFxcKS4gTGV0J3MgZmluYWxpemUgdGhpcyBwcmVzZW50YXRpb24hIn1dfSx7ImlkIjoibXNnXzA1N2U2N2I4ZjZiYzViZWMwMDY5ZDZjMjllOTMzNDgxOTZhZDg1Njg1YWJkMjBhMWE1IiwidHlwZSI6Im1lc3NhZ2UiLCJzdGF0dXMiOiJjb21wbGV0ZWQiLCJjb250ZW50IjpbeyJ0eXBlIjoib3V0cHV0X3RleHQiLCJhbm5vdGF0aW9ucyI6W10sImxvZ3Byb2JzIjpbXSwidGV4dCI6IlRoZSAxMHRoIHRlcm0gaXMgIFxu4oCCYeKCgeKCgCA9IDEwwrcoMTAgKyAxKSA9IDEwwrcxMSA9IDExMC4gIFxuXG5UaGUgc3VtIG9mIHRoZSBmaXJzdCAxMCB0ZXJtcyBpcyAgXG7igIJT4oKB4oKAID0g4oiRX3trPTF9XnsxMH0gayhrKzEpICBcbuKAguKAguKAgj0g4oiRa8KyICsg4oiRayAgXG7igILigILigII9ICgxMMK3MTHCtzIxKS82ICsgKDEwwrcxMSkvMiAgXG7igILigILigII9IDM4NSArIDU1ICBcbuKAguKAguKAgj0gNDQwLiAgXG5cbkVxdWl2YWxlbnRseSBvbmUgY2FuIHVzZSB0aGUgY2xvc2Vk4oCQZm9ybSAgXG7igIJT4oKZID0gbihuKzEpKG4rMikvMyAgXG5zbyAgXG7igIJT4oKB4oKAID0gMTDCtzExwrcxMi8zID0gNDQwLiJ9XSwicm9sZSI6ImFzc2lzdGFudCJ9XXoAhQEBAQAA"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNZWFADIAMErCA=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c2a1-668f7e245eb4750c7fa92d50;Parent=33d3a21173e47348;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:03:30 GMT",
- "Via" : "1.1 d08613e1dd8ad614e47875ae31a8af20.cloudfront.net (CloudFront), 1.1 83d24992402f7b214901ab76fbdc11e2.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c2a1000000000912ee2cbb745f3f",
- "x-amzn-RequestId" : "06b6b016-54e6-4278-b222-4f9b614ec176",
- "X-Amz-Cf-Id" : "T9TGRXdYGYYgBDU-21B6PHUrRSiLjtPoHEs3JoJmUf-MueBjOEBqAA==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "ae6954af-acc7-45f0-a532-5f0ba2033d07",
- "persistent" : true,
- "insertionIndex" : 135
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-b532f707-98c1-41af-8e1c-34574beeec45.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-b532f707-98c1-41af-8e1c-34574beeec45.json
deleted file mode 100644
index a69104ce..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-b532f707-98c1-41af-8e1c-34574beeec45.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "b532f707-98c1-41af-8e1c-34574beeec45",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CoULCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLNCQoRCg9icmFpbnRydXN0LWphdmEStwkKEI7jBQ4WuE1yPXreEvBP7KQSCPxJU0psTQCxKhlhbnRocm9waWMubWVzc2FnZXMuY3JlYXRlMAE5UFAi4LB9pBhB9AazDrF9pBhKkQEKFWJyYWludHJ1c3QuaW5wdXRfanNvbhJ4CnZbeyJjb250ZW50IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/Iiwicm9sZSI6InVzZXIifSx7InJvbGUiOiJzeXN0ZW0iLCJjb250ZW50IjoiWW91IGFyZSBhIGhlbHBmdWwgYXNzaXN0YW50In1dSnEKEmJyYWludHJ1c3QubWV0cmljcxJbCll7ImNvbXBsZXRpb25fdG9rZW5zIjoxMCwicHJvbXB0X3Rva2VucyI6MTksInRva2VucyI6MjksInRpbWVfdG9fZmlyc3RfdG9rZW4iOjAuMDA2MDAyNDEyfUoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3RKLgoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSEAoOeyJ0eXBlIjoibGxtIn1K0wQKFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SuAQKtQR7ImlkIjoibXNnXzAxRGJGOXZreGlSWW0yblZZQWUycGFnYyIsImNvbnRlbnQiOlt7ImNpdGF0aW9ucyI6bnVsbCwidGV4dCI6IlRoZSBjYXBpdGFsIG9mIEZyYW5jZSBpcyBQYXJpcy4iLCJ0eXBlIjoidGV4dCIsInZhbGlkIjp0cnVlfV0sIm1vZGVsIjoiY2xhdWRlLTMtaGFpa3UtMjAyNDAzMDciLCJyb2xlIjoiYXNzaXN0YW50Iiwic3RvcF9yZWFzb24iOiJlbmRfdHVybiIsInN0b3Bfc2VxdWVuY2UiOm51bGwsInR5cGUiOiJtZXNzYWdlIiwidXNhZ2UiOnsiY2FjaGVfY3JlYXRpb25faW5wdXRfdG9rZW5zIjowLCJjYWNoZV9yZWFkX2lucHV0X3Rva2VucyI6MCwiaW5wdXRfdG9rZW5zIjoxOSwib3V0cHV0X3Rva2VucyI6MTAsInNlcnZlcl90b29sX3VzZSI6bnVsbCwic2VydmljZV90aWVyIjoic3RhbmRhcmQiLCJ2YWxpZCI6dHJ1ZSwiaW5mZXJlbmNlX2dlbyI6Im5vdF9hdmFpbGFibGUiLCJjYWNoZV9jcmVhdGlvbiI6eyJlcGhlbWVyYWxfNW1faW5wdXRfdG9rZW5zIjowLCJlcGhlbWVyYWxfMWhfaW5wdXRfdG9rZW5zIjowfX0sInZhbGlkIjp0cnVlLCJzdG9wX2RldGFpbHMiOm51bGx9SqABChNicmFpbnRydXN0Lm1ldGFkYXRhEogBCoUBeyJwcm92aWRlciI6ImFudGhyb3BpYyIsInJlcXVlc3RfcGF0aCI6InYxL21lc3NhZ2VzIiwibW9kZWwiOiJjbGF1ZGUtMy1oYWlrdS0yMDI0MDMwNyIsInJlcXVlc3RfYmFzZV91cmkiOiIiLCJyZXF1ZXN0X21ldGhvZCI6IlBPU1QifXoAhQEBAQAA"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNvpGugIAMEFzg=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c330-4ee4a8ff2e52603248e4bbd0;Parent=36bdda2a29e9efc3;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:05:52 GMT",
- "Via" : "1.1 db84db36e16ca0c80b0992006d731900.cloudfront.net (CloudFront), 1.1 ffe9646b2ea911744e2d51fc0715cedc.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c330000000006b03d62afecdd8e1",
- "x-amzn-RequestId" : "069bf274-fc74-43dc-a06c-a244a13ff400",
- "X-Amz-Cf-Id" : "G9mmO3R8B3VgaRCTycl3B90x1mJnqOcJZsUeaO_ZpQ6z6AHkb9srnA==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "b532f707-98c1-41af-8e1c-34574beeec45",
- "persistent" : true,
- "insertionIndex" : 143
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-b7f91205-9930-4248-834c-37e913a19a55.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-b7f91205-9930-4248-834c-37e913a19a55.json
deleted file mode 100644
index d2f6f8a3..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-b7f91205-9930-4248-834c-37e913a19a55.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "b7f91205-9930-4248-834c-37e913a19a55",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "Cs4HCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjYtYzY3NjFlMgogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKWBgoRCg9icmFpbnRydXN0LWphdmESgAYKEBQJSzr7AHluWugA4r22NVISCEdMCovnu8UtKg9DaGF0IENvbXBsZXRpb24wATm4IqTZpcisGEHTXh8jpsisGEqRAQoVYnJhaW50cnVzdC5pbnB1dF9qc29uEngKdlt7ImNvbnRlbnQiOiJZb3UgYXJlIGEgaGVscGZ1bCBhc3Npc3RhbnQiLCJyb2xlIjoic3lzdGVtIn0seyJjb250ZW50IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/Iiwicm9sZSI6InVzZXIifV1KTgoSYnJhaW50cnVzdC5tZXRyaWNzEjgKNnsiY29tcGxldGlvbl90b2tlbnMiOjcsInByb21wdF90b2tlbnMiOjIzLCJ0b2tlbnMiOjMwfUouChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxIQCg57InR5cGUiOiJsbG0ifUoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3RKvQEKFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SogEKnwFbeyJpbmRleCI6MCwibWVzc2FnZSI6eyJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6IlRoZSBjYXBpdGFsIG9mIEZyYW5jZSBpcyBQYXJpcy4iLCJyZWZ1c2FsIjpudWxsLCJhbm5vdGF0aW9ucyI6W119LCJsb2dwcm9icyI6bnVsbCwiZmluaXNoX3JlYXNvbiI6InN0b3AifV1KrAEKE2JyYWludHJ1c3QubWV0YWRhdGESlAEKkQF7InByb3ZpZGVyIjoib3BlbmFpIiwicmVxdWVzdF9wYXRoIjoiY2hhdC9jb21wbGV0aW9ucyIsIm1vZGVsIjoiZ3B0LTRvLW1pbmkiLCJyZXF1ZXN0X2Jhc2VfdXJpIjoiaHR0cDovL2xvY2FsaG9zdDo2MTQyOSIsInJlcXVlc3RfbWV0aG9kIjoiUE9TVCJ9egCFAQEBAAA="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "c6Qg8HrooAMEmIA=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SFO53-P8", "SFO53-P1" ],
- "X-Amzn-Trace-Id" : "Root=1-69fa6138-2d09d9b9794ae47b2d991ed5;Parent=069a5502d6934f8f;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Tue, 05 May 2026 21:29:29 GMT",
- "Via" : "1.1 4a4857880fe33b59bd5c244742e8fe4e.cloudfront.net (CloudFront), 1.1 a11ff1ad6e4c16fe95e18b435889304a.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69fa613800000000307b5dbf427e160f",
- "x-amzn-RequestId" : "169aedf9-40cd-445c-a74c-6f6199e9aa31",
- "X-Amz-Cf-Id" : "hVOdUis_FjP_0JQc12SHFGbig2l0gO4dmVBt_R0u8Mbkwm220n3mUA==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "b7f91205-9930-4248-834c-37e913a19a55",
- "persistent" : true,
- "insertionIndex" : 256
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-ba6de2f6-d923-40b4-ab23-2186093eab38.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-ba6de2f6-d923-40b4-ab23-2186093eab38.json
deleted file mode 100644
index 0b7166b5..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-ba6de2f6-d923-40b4-ab23-2186093eab38.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "ba6de2f6-d923-40b4-ab23-2186093eab38",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CrcKCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBL/CAoRCg9icmFpbnRydXN0LWphdmES6QgKELk4HV19F1OrdWy0WE3yh2ESCJiiK/7m2RHdKhlhbnRocm9waWMubWVzc2FnZXMuY3JlYXRlMAE56Ik9zbt9pBhB6UYL/bt9pBhKLgoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSEAoOeyJ0eXBlIjoibGxtIn1KMgoRYnJhaW50cnVzdC5wYXJlbnQSHQobcHJvamVjdF9uYW1lOmphdmEtdW5pdC10ZXN0Sp4BChVicmFpbnRydXN0LmlucHV0X2pzb24ShAEKgQFbeyJjb250ZW50IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/Iiwicm9sZSI6InVzZXIifSx7InJvbGUiOiJzeXN0ZW0iLCJjb250ZW50IjoiWW91IGFyZSBhIGhlbHBmdWwgZ2VvZ3JhcGh5IGFzc2lzdGFudC4ifV1KTwoSYnJhaW50cnVzdC5tZXRyaWNzEjkKN3siY29tcGxldGlvbl90b2tlbnMiOjEwLCJwcm9tcHRfdG9rZW5zIjoyMSwidG9rZW5zIjozMX1KtgEKE2JyYWludHJ1c3QubWV0YWRhdGESngEKmwF7InByb3ZpZGVyIjoiYW50aHJvcGljIiwicmVxdWVzdF9wYXRoIjoidjEvbWVzc2FnZXMiLCJtb2RlbCI6ImNsYXVkZS0zLWhhaWt1LTIwMjQwMzA3IiwicmVxdWVzdF9iYXNlX3VyaSI6Imh0dHA6Ly9sb2NhbGhvc3Q6NDAyNzEiLCJyZXF1ZXN0X21ldGhvZCI6IlBPU1QifUqEBAoWYnJhaW50cnVzdC5vdXRwdXRfanNvbhLpAwrmA3sibW9kZWwiOiJjbGF1ZGUtMy1oYWlrdS0yMDI0MDMwNyIsImlkIjoibXNnXzAxTGNSTUpGc2dEYUNqeGV0YTdVclJvOSIsInR5cGUiOiJtZXNzYWdlIiwicm9sZSI6ImFzc2lzdGFudCIsImNvbnRlbnQiOlt7InR5cGUiOiJ0ZXh0IiwidGV4dCI6IlRoZSBjYXBpdGFsIG9mIEZyYW5jZSBpcyBQYXJpcy4ifV0sInN0b3BfcmVhc29uIjoiZW5kX3R1cm4iLCJzdG9wX3NlcXVlbmNlIjpudWxsLCJzdG9wX2RldGFpbHMiOm51bGwsInVzYWdlIjp7ImlucHV0X3Rva2VucyI6MjEsImNhY2hlX2NyZWF0aW9uX2lucHV0X3Rva2VucyI6MCwiY2FjaGVfcmVhZF9pbnB1dF90b2tlbnMiOjAsImNhY2hlX2NyZWF0aW9uIjp7ImVwaGVtZXJhbF81bV9pbnB1dF90b2tlbnMiOjAsImVwaGVtZXJhbF8xaF9pbnB1dF90b2tlbnMiOjB9LCJvdXRwdXRfdG9rZW5zIjoxMCwic2VydmljZV90aWVyIjoic3RhbmRhcmQiLCJpbmZlcmVuY2VfZ2VvIjoibm90X2F2YWlsYWJsZSJ9fXoAhQEBAQAA"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhN3AE7aIAMERdg=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c35f-6353fdad1c765f2231db0a33;Parent=637481c9c2c50475;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:06:39 GMT",
- "Via" : "1.1 d118b2ea8414d381f46f91331ab67f02.cloudfront.net (CloudFront), 1.1 77f3c89ffd619275648d49ad13868570.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c35f000000005406815c885b39c5",
- "x-amzn-RequestId" : "4cb133d2-b124-437e-bc9c-c4e009dd67b8",
- "X-Amz-Cf-Id" : "-DyEpj4HsRKxgemB-QD1rdRfsorzQMO0MAWSY_Qh41pxxPJWo_htsA==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "ba6de2f6-d923-40b4-ab23-2186093eab38",
- "persistent" : true,
- "insertionIndex" : 160
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-c13ae131-4f12-40a1-ab09-647658eb0bc3.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-c13ae131-4f12-40a1-ab09-647658eb0bc3.json
deleted file mode 100644
index 7e700772..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-c13ae131-4f12-40a1-ab09-647658eb0bc3.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "c13ae131-4f12-40a1-ab09-647658eb0bc3",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CtgKCrgBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAooCg9zZXJ2aWNlLnZlcnNpb24SFQoTMC4zLjQtYjIyODA5ZS1ESVJUWQogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKaCQoRCg9icmFpbnRydXN0LWphdmEShAkKECRIpVlolhZqJqJYYazH7NkSCJ8eV996EPX5KhlhbnRocm9waWMubWVzc2FnZXMuY3JlYXRlMAE5BKiZC+l/qxhB/WBLpOl/qxhKkAQKFmJyYWludHJ1c3Qub3V0cHV0X2pzb24S9QMK8gN7Im1vZGVsIjoiY2xhdWRlLXNvbm5ldC00LTUtMjAyNTA5MjkiLCJpZCI6Im1zZ18wMTRCaTRZV3ZDSkxrcWNYc0o1RXFkZ2MiLCJ0eXBlIjoibWVzc2FnZSIsInJvbGUiOiJhc3Npc3RhbnQiLCJjb250ZW50IjpbeyJ0eXBlIjoidGV4dCIsInRleHQiOiJUaGUgY2FwaXRhbCBvZiBGcmFuY2UgaXMgUGFyaXMuIn1dLCJzdG9wX3JlYXNvbiI6ImVuZF90dXJuIiwic3RvcF9zZXF1ZW5jZSI6bnVsbCwic3RvcF9kZXRhaWxzIjpudWxsLCJ1c2FnZSI6eyJpbnB1dF90b2tlbnMiOjEyLCJjYWNoZV9jcmVhdGlvbl9pbnB1dF90b2tlbnMiOjc0MjUsImNhY2hlX3JlYWRfaW5wdXRfdG9rZW5zIjowLCJjYWNoZV9jcmVhdGlvbiI6eyJlcGhlbWVyYWxfNW1faW5wdXRfdG9rZW5zIjozNzEwLCJlcGhlbWVyYWxfMWhfaW5wdXRfdG9rZW5zIjozNzE1fSwib3V0cHV0X3Rva2VucyI6MTAsInNlcnZpY2VfdGllciI6InN0YW5kYXJkIiwiaW5mZXJlbmNlX2dlbyI6Im5vdF9hdmFpbGFibGUifX1KowEKE2JyYWludHJ1c3QubWV0YWRhdGESiwEKiAF7InByb3ZpZGVyIjoiYW50aHJvcGljIiwicmVxdWVzdF9wYXRoIjoidjEvbWVzc2FnZXMiLCJtb2RlbCI6ImNsYXVkZS1zb25uZXQtNC01LTIwMjUwOTI5IiwicmVxdWVzdF9iYXNlX3VyaSI6IiIsInJlcXVlc3RfbWV0aG9kIjoiUE9TVCJ9SlcKFWJyYWludHJ1c3QuaW5wdXRfanNvbhI+CjxbeyJjb250ZW50IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/Iiwicm9sZSI6InVzZXIifV1KuAEKEmJyYWludHJ1c3QubWV0cmljcxKhAQqeAXsiY29tcGxldGlvbl90b2tlbnMiOjEwLCJwcm9tcHRfdG9rZW5zIjoxMiwicHJvbXB0X2NhY2hlX2NyZWF0aW9uXzFoX3Rva2VucyI6MzcxNSwicHJvbXB0X2NhY2hlZF90b2tlbnMiOjAsInRva2VucyI6MjIsInByb21wdF9jYWNoZV9jcmVhdGlvbl81bV90b2tlbnMiOjM3MTB9Si4KGmJyYWludHJ1c3Quc3Bhbl9hdHRyaWJ1dGVzEhAKDnsidHlwZSI6ImxsbSJ9SjIKEWJyYWludHJ1c3QucGFyZW50Eh0KG3Byb2plY3RfbmFtZTpqYXZhLXVuaXQtdGVzdHoAhQEBAQAA"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cseEeEqSIAMEnQg=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69f4dd4f-0078f8c618f258e9039f7961;Parent=360ca855d5e4d60e;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Fri, 01 May 2026 17:05:19 GMT",
- "Via" : "1.1 9257f9c4051fe8bd6cc4a09855b66350.cloudfront.net (CloudFront), 1.1 a40ac7dad0e348fc93799233c9af5960.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69f4dd4f0000000021bd7e2acd5662f0",
- "x-amzn-RequestId" : "edd69fb6-c6ad-4934-9be0-fc038866a148",
- "X-Amz-Cf-Id" : "pX7jRpcl0r55aLbaj4nEkBicsT_lb-AAW1JHzEmGHPVJQe0MUAaTKA==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "c13ae131-4f12-40a1-ab09-647658eb0bc3",
- "persistent" : true,
- "insertionIndex" : 248
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-c70681cf-91f2-4471-98e5-d8687d959930.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-c70681cf-91f2-4471-98e5-d8687d959930.json
deleted file mode 100644
index 3b67f04c..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-c70681cf-91f2-4471-98e5-d8687d959930.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "c70681cf-91f2-4471-98e5-d8687d959930",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CsEICrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKJBwoRCg9icmFpbnRydXN0LWphdmES8wYKENPpJae1ky2iqEcAHIEa+koSCMfvBJmh5wP8KglyZXNwb25zZXMwATlfraS+t32kGEH7K8N8uH2kGEqhAQoTYnJhaW50cnVzdC5tZXRhZGF0YRKJAQqGAXsicHJvdmlkZXIiOiJvcGVuYWkiLCJyZXF1ZXN0X3BhdGgiOiJyZXNwb25zZXMiLCJtb2RlbCI6Im80LW1pbmkiLCJyZXF1ZXN0X2Jhc2VfdXJpIjoiaHR0cDovL2xvY2FsaG9zdDozNzAwNSIsInJlcXVlc3RfbWV0aG9kIjoiUE9TVCJ9SsgCChZicmFpbnRydXN0Lm91dHB1dF9qc29uEq0CCqoCW3siaWQiOiJyc18wOGRjZjg3YmNmYzAwMzkyMDA2OWQ2YzM0ZWZhZTQ4MTk3OTc3OTUxYzg4YzFhMTMzMyIsInR5cGUiOiJyZWFzb25pbmciLCJzdW1tYXJ5IjpbXX0seyJpZCI6Im1zZ18wOGRjZjg3YmNmYzAwMzkyMDA2OWQ2YzM0ZmE0ZDA4MTk3YTg5ZjFkZTZkZjFlZWYwNiIsInR5cGUiOiJtZXNzYWdlIiwic3RhdHVzIjoiY29tcGxldGVkIiwiY29udGVudCI6W3sidHlwZSI6Im91dHB1dF90ZXh0IiwiYW5ub3RhdGlvbnMiOltdLCJsb2dwcm9icyI6W10sInRleHQiOiJQYXJpcyJ9XSwicm9sZSI6ImFzc2lzdGFudCJ9XUouChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxIQCg57InR5cGUiOiJsbG0ifUoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3RKagoVYnJhaW50cnVzdC5pbnB1dF9qc29uElEKT1t7ImNvbnRlbnQiOiJXaGF0IGlzIHRoZSBjYXBpdGFsIG9mIEZyYW5jZT8gUmVwbHkgaW4gb25lIHdvcmQuIiwicm9sZSI6InVzZXIifV1KbwoSYnJhaW50cnVzdC5tZXRyaWNzElkKV3siY29tcGxldGlvbl90b2tlbnMiOjM2LCJwcm9tcHRfdG9rZW5zIjoxOCwidG9rZW5zIjo1NCwiY29tcGxldGlvbl9yZWFzb25pbmdfdG9rZW5zIjowfXoAhQEBAQAA"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhN0pGdzIAMETrQ=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c350-2f0fe5dc09d6baed5b94e1c1;Parent=1690335aa9854257;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:06:24 GMT",
- "Via" : "1.1 db84db36e16ca0c80b0992006d731900.cloudfront.net (CloudFront), 1.1 b3ccaedda78c63d5967b57382ceb4cbe.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c35000000000010463895e540596",
- "x-amzn-RequestId" : "047e4618-9c23-49f9-a45f-f88ade7268f5",
- "X-Amz-Cf-Id" : "Wdwa2oyqxacER2xq_EyYGLTeTauLerWH_Yww2ryDR96ZodM4d5CVCw==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "c70681cf-91f2-4471-98e5-d8687d959930",
- "persistent" : true,
- "insertionIndex" : 155
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-c9f40527-e4f6-48f7-bb17-ff42e8693f3e.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-c9f40527-e4f6-48f7-bb17-ff42e8693f3e.json
deleted file mode 100644
index a0b8cda7..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-c9f40527-e4f6-48f7-bb17-ff42e8693f3e.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "c9f40527-e4f6-48f7-bb17-ff42e8693f3e",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNaMG__oAMEXzQ=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c2a7-3bfebcd22424766f4a94d751;Parent=18097296100504c8;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:03:35 GMT",
- "Via" : "1.1 724581b48d733e53834b535d2a623034.cloudfront.net (CloudFront), 1.1 65f2e9f7f1475de54aa452d3ceb9bcf6.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c2a7000000000691d15166c47e45",
- "x-amzn-RequestId" : "babea881-dffc-45f3-a3b7-2cd44cf8e035",
- "X-Amz-Cf-Id" : "LInZJtQCnrALTdFbQQ-Gmo8Edk47-ZQVYAfcBpHx9Ia__-CiYN1aew==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "c9f40527-e4f6-48f7-bb17-ff42e8693f3e",
- "persistent" : true,
- "insertionIndex" : 134
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-d4e8140a-45ef-49ba-9415-7d484f57c35d.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-d4e8140a-45ef-49ba-9415-7d484f57c35d.json
deleted file mode 100644
index f85e920f..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-d4e8140a-45ef-49ba-9415-7d484f57c35d.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "d4e8140a-45ef-49ba-9415-7d484f57c35d",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNRDFq7IAMElog=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c26c-6bdd9e656dd845391c38b9ca;Parent=3c499e62564913a5;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:02:36 GMT",
- "Via" : "1.1 db84db36e16ca0c80b0992006d731900.cloudfront.net (CloudFront), 1.1 a40ac7dad0e348fc93799233c9af5960.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c26c00000000604ac0d1f34d0550",
- "x-amzn-RequestId" : "5690ce9a-d458-4c56-ae81-3bc1e8fed7f8",
- "X-Amz-Cf-Id" : "LK_WFtxNzrbgu6lJNb99TLOCkUUKRJ8YkQXoQpmSNvZZYfyNSNV7dQ==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "d4e8140a-45ef-49ba-9415-7d484f57c35d",
- "persistent" : true,
- "insertionIndex" : 51
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-d6d01c21-41ac-4abe-b193-c8570176e7d8.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-d6d01c21-41ac-4abe-b193-c8570176e7d8.json
deleted file mode 100644
index 8c9ad4f7..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-d6d01c21-41ac-4abe-b193-c8570176e7d8.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "d6d01c21-41ac-4abe-b193-c8570176e7d8",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cseGcEKNoAMEnng=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69f4dd5c-7dd541fb4ded191b52feb320;Parent=6fcf029ac18791b2;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Fri, 01 May 2026 17:05:32 GMT",
- "Via" : "1.1 c9f68a0c96944962731456040c591f26.cloudfront.net (CloudFront), 1.1 4ac8d091dce10e726cfc5404bfed72b8.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69f4dd5c000000001841a520c0f52dc3",
- "x-amzn-RequestId" : "d734ce80-35a4-4160-a313-780165dc1aa2",
- "X-Amz-Cf-Id" : "nWVjPERm8srxLZs3zbwDXNZCZ7qXI-xHtAFVgSgA4Kq99DX45HXNlA==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "d6d01c21-41ac-4abe-b193-c8570176e7d8",
- "persistent" : true,
- "insertionIndex" : 242
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-d95535f4-bef1-4619-a985-dcd995c550d6.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-d95535f4-bef1-4619-a985-dcd995c550d6.json
deleted file mode 100644
index 6368317b..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-d95535f4-bef1-4619-a985-dcd995c550d6.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "d95535f4-bef1-4619-a985-dcd995c550d6",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cqZaIFreIAMEA9w=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69f4090d-3f3f39b50ba700de323ffa1b;Parent=183c55d7b3e59f46;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Fri, 01 May 2026 01:59:41 GMT",
- "Via" : "1.1 b7d7903ada432685f0e90f0ca261d864.cloudfront.net (CloudFront), 1.1 fbb003dfc0617e3e058e3dac791dfd5a.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69f4090d0000000020450c542c10d558",
- "x-amzn-RequestId" : "72deb0b3-3aa1-4309-97c1-64042a7b0b2c",
- "X-Amz-Cf-Id" : "8Vr9lIG9I6WkIX9E7dJXPlZ8caYaotkV1MR5SbJ82JRgwiijKO4rFg==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "d95535f4-bef1-4619-a985-dcd995c550d6",
- "persistent" : true,
- "insertionIndex" : 237
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-d98e7a0b-453c-4c82-bfc5-eaa456eb6744.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-d98e7a0b-453c-4c82-bfc5-eaa456eb6744.json
deleted file mode 100644
index abde2d45..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-d98e7a0b-453c-4c82-bfc5-eaa456eb6744.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "d98e7a0b-453c-4c82-bfc5-eaa456eb6744",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNXnFaSoAMEXdA=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c296-74e12b616bebd7a72521dddd;Parent=01cdf6bb9be4e6d4;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:03:19 GMT",
- "Via" : "1.1 59e4792b9d6184bfa491a317b36590d2.cloudfront.net (CloudFront), 1.1 d9d466ed70d93f34739969f91577ec74.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c296000000001131b88a2cfccddc",
- "x-amzn-RequestId" : "b22b84c9-2b72-4634-9e77-62095944490e",
- "X-Amz-Cf-Id" : "OpSYoq8eTpqOLPWwyH_PlPpPZZP2zVqSOl3bIwkyXiFP5Z12UgXNSQ==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "d98e7a0b-453c-4c82-bfc5-eaa456eb6744",
- "persistent" : true,
- "insertionIndex" : 137
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-da2cc964-ede4-435e-aa2a-2db24d5ecc0f.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-da2cc964-ede4-435e-aa2a-2db24d5ecc0f.json
deleted file mode 100644
index 918c7ef4..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-da2cc964-ede4-435e-aa2a-2db24d5ecc0f.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "da2cc964-ede4-435e-aa2a-2db24d5ecc0f",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CuUHCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjYtYzY3NjFlMgogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKtBgoRCg9icmFpbnRydXN0LWphdmESlwYKEOEez6/NNfZQ/uVXPeMwG4sSCEEI/AH150gBKglyZXNwb25zZXMwATmwOI41p8isGEFH6MFsp8isGEpqChVicmFpbnRydXN0LmlucHV0X2pzb24SUQpPW3siY29udGVudCI6IldoYXQgaXMgdGhlIGNhcGl0YWwgb2YgRnJhbmNlPyBSZXBseSBpbiBvbmUgd29yZC4iLCJyb2xlIjoidXNlciJ9XUpuChJicmFpbnRydXN0Lm1ldHJpY3MSWApWeyJjb21wbGV0aW9uX3Rva2VucyI6MiwicHJvbXB0X3Rva2VucyI6MjgsInRva2VucyI6MzAsImNvbXBsZXRpb25fcmVhc29uaW5nX3Rva2VucyI6MH1KLgoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSEAoOeyJ0eXBlIjoibGxtIn1KMgoRYnJhaW50cnVzdC5wYXJlbnQSHQobcHJvamVjdF9uYW1lOmphdmEtdW5pdC10ZXN0SukBChZicmFpbnRydXN0Lm91dHB1dF9qc29uEs4BCssBW3siaWQiOiJtc2dfMDlmMTNiYWU2ZjM2NDJlNDAwNjlmYTYxM2RmYzc0ODE5NDk5MTI3ZWI3NGQxNTFkYzMiLCJ0eXBlIjoibWVzc2FnZSIsInN0YXR1cyI6ImNvbXBsZXRlZCIsImNvbnRlbnQiOlt7InR5cGUiOiJvdXRwdXRfdGV4dCIsImFubm90YXRpb25zIjpbXSwibG9ncHJvYnMiOltdLCJ0ZXh0IjoiUGFyaXMifV0sInJvbGUiOiJhc3Npc3RhbnQifV1KpQEKE2JyYWludHJ1c3QubWV0YWRhdGESjQEKigF7InByb3ZpZGVyIjoib3BlbmFpIiwicmVxdWVzdF9wYXRoIjoicmVzcG9uc2VzIiwibW9kZWwiOiJncHQtNG8tbWluaSIsInJlcXVlc3RfYmFzZV91cmkiOiJodHRwOi8vbG9jYWxob3N0OjYxNDI5IiwicmVxdWVzdF9tZXRob2QiOiJQT1NUIn16AIUBAQEAAA=="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "c6QhzHs1oAMELrQ=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SFO53-P8", "SFO53-P1" ],
- "X-Amzn-Trace-Id" : "Root=1-69fa613e-1751732f7f6ba19b56f99024;Parent=618472f86815a9a8;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Tue, 05 May 2026 21:29:34 GMT",
- "Via" : "1.1 0d596bf21dbb8ca0d865a97c7e7bb19c.cloudfront.net (CloudFront), 1.1 459b85c545909b647abc5dea4320a0da.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69fa613e000000005609049842771ce2",
- "x-amzn-RequestId" : "52b1215e-6bd4-4cb9-954f-326136df2431",
- "X-Amz-Cf-Id" : "Mi2Y0lACQWEgcQyUhLrUkCEv-SY0b-_5cElQjs9ypj-SQEWIENueDA==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "da2cc964-ede4-435e-aa2a-2db24d5ecc0f",
- "persistent" : true,
- "insertionIndex" : 253
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-dce37b28-875c-4bc9-808d-31d778c6a1c3.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-dce37b28-875c-4bc9-808d-31d778c6a1c3.json
deleted file mode 100644
index f4b8c968..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-dce37b28-875c-4bc9-808d-31d778c6a1c3.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "dce37b28-875c-4bc9-808d-31d778c6a1c3",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CvoICrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLCBwoRCg9icmFpbnRydXN0LWphdmESrAcKENhij0OAo6Aydbc8mOK8aAkSCL9Bnuj3oGnGKhlhbnRocm9waWMubWVzc2FnZXMuY3JlYXRlMAE5YtsYML19pBhBOqpYcb19pBhKLgoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSEAoOeyJ0eXBlIjoibGxtIn1KMgoRYnJhaW50cnVzdC5wYXJlbnQSHQobcHJvamVjdF9uYW1lOmphdmEtdW5pdC10ZXN0SlcKFWJyYWludHJ1c3QuaW5wdXRfanNvbhI+CjxbeyJjb250ZW50IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/Iiwicm9sZSI6InVzZXIifV1KcQoSYnJhaW50cnVzdC5tZXRyaWNzElsKWXsiY29tcGxldGlvbl90b2tlbnMiOjEwLCJwcm9tcHRfdG9rZW5zIjoxNCwidG9rZW5zIjoyNCwidGltZV90b19maXJzdF90b2tlbiI6MS4wMjYxMTAxODV9SrYBChNicmFpbnRydXN0Lm1ldGFkYXRhEp4BCpsBeyJwcm92aWRlciI6ImFudGhyb3BpYyIsInJlcXVlc3RfcGF0aCI6InYxL21lc3NhZ2VzIiwibW9kZWwiOiJjbGF1ZGUtMy1oYWlrdS0yMDI0MDMwNyIsInJlcXVlc3RfYmFzZV91cmkiOiJodHRwOi8vbG9jYWxob3N0OjQwMjcxIiwicmVxdWVzdF9tZXRob2QiOiJQT1NUIn1K6wIKFmJyYWludHJ1c3Qub3V0cHV0X2pzb24S0AIKzQJ7InJvbGUiOiJhc3Npc3RhbnQiLCJjb250ZW50IjpbeyJ0eXBlIjoidGV4dCIsInRleHQiOiJUaGUgY2FwaXRhbCBvZiBGcmFuY2UgaXMgUGFyaXMuIn1dLCJ1c2FnZSI6eyJpbnB1dF90b2tlbnMiOjE0LCJjYWNoZV9jcmVhdGlvbl9pbnB1dF90b2tlbnMiOjAsImNhY2hlX3JlYWRfaW5wdXRfdG9rZW5zIjowLCJjYWNoZV9jcmVhdGlvbiI6eyJlcGhlbWVyYWxfNW1faW5wdXRfdG9rZW5zIjowLCJlcGhlbWVyYWxfMWhfaW5wdXRfdG9rZW5zIjowfSwib3V0cHV0X3Rva2VucyI6MTAsInNlcnZpY2VfdGllciI6InN0YW5kYXJkIiwiaW5mZXJlbmNlX2dlbyI6Im5vdF9hdmFpbGFibGUifX1QAXoAhQEBAQAA"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhN4DF2qIAMEbpQ=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c366-17eb717c587b6305535ac8b9;Parent=3c5047c3151c4184;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:06:46 GMT",
- "Via" : "1.1 940972e9e344075576fe20d5db482122.cloudfront.net (CloudFront), 1.1 a40ac7dad0e348fc93799233c9af5960.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c3660000000049cbebb9f3e66d8b",
- "x-amzn-RequestId" : "d9e8b0e1-2a1a-4c37-b068-1c357334dc98",
- "X-Amz-Cf-Id" : "OPIAiRKBiL6qcE4-RzUmh63bNAeWR1o9soTuCD0JHrMY08P6gL1EHA==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "dce37b28-875c-4bc9-808d-31d778c6a1c3",
- "persistent" : true,
- "insertionIndex" : 156
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-dd1e558d-523c-4189-bfd0-d1808c9a7233.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-dd1e558d-523c-4189-bfd0-d1808c9a7233.json
deleted file mode 100644
index 3abcc3fc..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-dd1e558d-523c-4189-bfd0-d1808c9a7233.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "dd1e558d-523c-4189-bfd0-d1808c9a7233",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CusDCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKTAQoNCgt0ZXN0LWNsaWVudBKBAQoQ8wxz7J5bz/lcTiFXDEmmMhII4D4L2IFXdskqEGNsaWVudC1vcGVyYXRpb24wATnKcq2QiH2kGEEw7i+RiH2kGEo1ChFicmFpbnRydXN0LnBhcmVudBIgCh5leHBlcmltZW50X2lkOmFiYzEyMy1odHRwLXRlc3R6AIUBAQEAABKdAQoNCgt0ZXN0LXNlcnZlchKLAQoQ8wxz7J5bz/lcTiFXDEmmMhIIqz37LcLwURAiCOA+C9iBV3bJKhBzZXJ2ZXItb3BlcmF0aW9uMAE5JAwckYh9pBhBmTwikYh9pBhKNQoRYnJhaW50cnVzdC5wYXJlbnQSIAoeZXhwZXJpbWVudF9pZDphYmMxMjMtaHR0cC10ZXN0egCFAQEDAAA="
- } ]
- },
- "response" : {
- "status" : 403,
- "bodyFileName" : "otel_v1_traces-dd1e558d-523c-4189-bfd0-d1808c9a7233.json",
- "headers" : {
- "X-Cache" : "Error from cloudfront",
- "x-amz-apigw-id" : "bhNUeEVioAMEhVw=",
- "vary" : "Origin, Accept-Encoding",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c282-753861e01a53ef52175edac0;Parent=2d215db3033547fb;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:02:58 GMT",
- "Via" : "1.1 db84db36e16ca0c80b0992006d731900.cloudfront.net (CloudFront), 1.1 73b0c4a85645a8031ba157e0b3e28ffc.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c282000000005868ea9bb6bc3400",
- "x-amzn-RequestId" : "1eeb994a-9ce3-496b-8766-a96f02825f70",
- "X-Amz-Cf-Id" : "XqMEAojmfWTE2TEp50MryxUTXALWyn1nUYR59k3XjETbC-zIQ5cUaQ==",
- "etag" : "W/\"13b-7+Z2sx0l7SYpQTk7zOce4Y8+FL0\"",
- "Content-Type" : "application/json; charset=utf-8"
- }
- },
- "uuid" : "dd1e558d-523c-4189-bfd0-d1808c9a7233",
- "persistent" : true,
- "insertionIndex" : 1
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-e02b29a4-8596-404a-8e85-8fe952f8b285.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-e02b29a4-8596-404a-8e85-8fe952f8b285.json
deleted file mode 100644
index b5a4d3a7..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-e02b29a4-8596-404a-8e85-8fe952f8b285.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "e02b29a4-8596-404a-8e85-8fe952f8b285",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CuACCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjQtOTczNzYyMQogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKoAQoYChZkaXN0cmlidXRlZC10cmFjZS10ZXN0EosBChC5oj3OwM4rcfVYYrO0dWJWEgiLfaT9jaVggSoddGVzdC1kaXN0cmlidXRlZC10cmFjZS1wYXJlbnQwATkoFX8aMVOqGEES94FtMVOqGEoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3R6AIUBAQEAAA=="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cf21SE7oIAMEk5w=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69efd1bb-745994e35a3623381ffccf2b;Parent=585ce84ee19052f3;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Mon, 27 Apr 2026 21:14:35 GMT",
- "Via" : "1.1 2be627c4e85d6d9d9e32a7523e1b67ee.cloudfront.net (CloudFront), 1.1 566cc276dff9847158a5a9854be4df42.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69efd1bb0000000050b6603e74a2e99e",
- "x-amzn-RequestId" : "d42d5ad5-4f0b-4eb9-8aa8-66b65ba38ad3",
- "X-Amz-Cf-Id" : "cUnHMzsffp7urYY3bAHn1rWJUVQZmPMQl3hmny5bKLkj9V_xsldXFw==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "e02b29a4-8596-404a-8e85-8fe952f8b285",
- "persistent" : true,
- "insertionIndex" : 185
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-ea795ac1-db7b-4709-b2ad-1252eb5b95aa.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-ea795ac1-db7b-4709-b2ad-1252eb5b95aa.json
deleted file mode 100644
index f0dd89dd..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-ea795ac1-db7b-4709-b2ad-1252eb5b95aa.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "ea795ac1-db7b-4709-b2ad-1252eb5b95aa",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "Cs4HCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKWBgoRCg9icmFpbnRydXN0LWphdmESgAYKEFw00LRNVGAFL2a+mGhHCl4SCKrzWDqs0R//Kg9DaGF0IENvbXBsZXRpb24wATl5FX6tuX2kGEGaUYbeuX2kGEqsAQoTYnJhaW50cnVzdC5tZXRhZGF0YRKUAQqRAXsicHJvdmlkZXIiOiJvcGVuYWkiLCJyZXF1ZXN0X3BhdGgiOiJjaGF0L2NvbXBsZXRpb25zIiwibW9kZWwiOiJncHQtNG8tbWluaSIsInJlcXVlc3RfYmFzZV91cmkiOiJodHRwOi8vbG9jYWxob3N0OjM3MDA1IiwicmVxdWVzdF9tZXRob2QiOiJQT1NUIn1KvQEKFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SogEKnwFbeyJpbmRleCI6MCwibWVzc2FnZSI6eyJyb2xlIjoiYXNzaXN0YW50IiwiY29udGVudCI6IlRoZSBjYXBpdGFsIG9mIEZyYW5jZSBpcyBQYXJpcy4iLCJyZWZ1c2FsIjpudWxsLCJhbm5vdGF0aW9ucyI6W119LCJsb2dwcm9icyI6bnVsbCwiZmluaXNoX3JlYXNvbiI6InN0b3AifV1KLgoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSEAoOeyJ0eXBlIjoibGxtIn1KMgoRYnJhaW50cnVzdC5wYXJlbnQSHQobcHJvamVjdF9uYW1lOmphdmEtdW5pdC10ZXN0SpEBChVicmFpbnRydXN0LmlucHV0X2pzb24SeAp2W3siY29udGVudCI6IllvdSBhcmUgYSBoZWxwZnVsIGFzc2lzdGFudCIsInJvbGUiOiJzeXN0ZW0ifSx7ImNvbnRlbnQiOiJXaGF0IGlzIHRoZSBjYXBpdGFsIG9mIEZyYW5jZT8iLCJyb2xlIjoidXNlciJ9XUpOChJicmFpbnRydXN0Lm1ldHJpY3MSOAo2eyJjb21wbGV0aW9uX3Rva2VucyI6NywicHJvbXB0X3Rva2VucyI6MjMsInRva2VucyI6MzB9egCFAQEBAAA="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhN1kE2poAMEYzw=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c356-357643050833a9c40b36deab;Parent=7986066e3d903592;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:06:30 GMT",
- "Via" : "1.1 b7e07d6a19a4c8b2e410e9c1e173548c.cloudfront.net (CloudFront), 1.1 77f3c89ffd619275648d49ad13868570.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c356000000006e9c7f2daefa2d1a",
- "x-amzn-RequestId" : "b6b01a8d-1ac1-40ee-9835-47211c77bf5f",
- "X-Amz-Cf-Id" : "rAHQ2FpR_ydmpQrKg5C7L9e1IxTSv4p_c0AkGPDFndGiM8qmzzJyOQ==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "ea795ac1-db7b-4709-b2ad-1252eb5b95aa",
- "persistent" : true,
- "insertionIndex" : 151
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-eab030fd-4e00-4af8-b5a6-2759e4759e9f.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-eab030fd-4e00-4af8-b5a6-2759e4759e9f.json
deleted file mode 100644
index 7a8afee5..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-eab030fd-4e00-4af8-b5a6-2759e4759e9f.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "eab030fd-4e00-4af8-b5a6-2759e4759e9f",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cqZXjGd3oAMEB_A=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69f408fc-6672bcf7223a54ac34a5c484;Parent=1bb1410113bd85e6;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Fri, 01 May 2026 01:59:24 GMT",
- "Via" : "1.1 e1832834d17ab65dd955f4e68cc524e6.cloudfront.net (CloudFront), 1.1 74e8c76139b8c7f9b11d5e4441c2a7a2.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69f408fc000000005f55eb177bdacde2",
- "x-amzn-RequestId" : "969805cb-28c2-4901-b3aa-a562348da4a0",
- "X-Amz-Cf-Id" : "QySVXgvAVV7mVard1JArPs8VDS5T77pjTVwfHCsZePI_xMXzNTVSzg==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "eab030fd-4e00-4af8-b5a6-2759e4759e9f",
- "persistent" : true,
- "insertionIndex" : 240
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-eb149792-2d60-4963-9808-9a8bf6326d31.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-eb149792-2d60-4963-9808-9a8bf6326d31.json
deleted file mode 100644
index b467743b..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-eb149792-2d60-4963-9808-9a8bf6326d31.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "eb149792-2d60-4963-9808-9a8bf6326d31",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cFzpBEeSoAMEc-g=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69e56639-2b6eaac951e9bc691575c14e;Parent=6220ccf7b0a1a2bf;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Sun, 19 Apr 2026 23:33:13 GMT",
- "Via" : "1.1 2c24d855455b80190edd9e2dcdca3ee8.cloudfront.net (CloudFront), 1.1 a53bab1af200813b8f27e3c0a28b4964.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69e5663900000000768fc4ee912537cc",
- "x-amzn-RequestId" : "96b7e297-bb0f-40b3-aa53-34eb1707485a",
- "X-Amz-Cf-Id" : "jVfE0hTszQmLIU5DgAThDfyFNGoOGjOnEz621Hc4AESibNA1wdXR9Q==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "eb149792-2d60-4963-9808-9a8bf6326d31",
- "persistent" : true,
- "insertionIndex" : 168
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-ecd72a15-bc56-4af7-8f3a-ea007535f361.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-ecd72a15-bc56-4af7-8f3a-ea007535f361.json
deleted file mode 100644
index b61457e9..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-ecd72a15-bc56-4af7-8f3a-ea007535f361.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "ecd72a15-bc56-4af7-8f3a-ea007535f361",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CtsHCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKjBgoRCg9icmFpbnRydXN0LWphdmESjQYKEFWX+yfHtfjI9CGEpOHFgp0SCE8fwv1IloxXKg9DaGF0IENvbXBsZXRpb24wATmBlw46u32kGEGL36OBu32kGEouChpicmFpbnRydXN0LnNwYW5fYXR0cmlidXRlcxIQCg57InR5cGUiOiJsbG0ifUoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3RKngEKFWJyYWludHJ1c3QuaW5wdXRfanNvbhKEAQqBAVt7ImNvbnRlbnQiOiJZb3UgYXJlIGEgaGVscGZ1bCBnZW9ncmFwaHkgYXNzaXN0YW50LiIsInJvbGUiOiJzeXN0ZW0ifSx7ImNvbnRlbnQiOiJXaGF0IGlzIHRoZSBjYXBpdGFsIG9mIEZyYW5jZT8iLCJyb2xlIjoidXNlciJ9XUpOChJicmFpbnRydXN0Lm1ldHJpY3MSOAo2eyJjb21wbGV0aW9uX3Rva2VucyI6NywicHJvbXB0X3Rva2VucyI6MjUsInRva2VucyI6MzJ9SqwBChNicmFpbnRydXN0Lm1ldGFkYXRhEpQBCpEBeyJwcm92aWRlciI6Im9wZW5haSIsInJlcXVlc3RfcGF0aCI6ImNoYXQvY29tcGxldGlvbnMiLCJtb2RlbCI6ImdwdC00by1taW5pIiwicmVxdWVzdF9iYXNlX3VyaSI6Imh0dHA6Ly9sb2NhbGhvc3Q6MzY4MDEiLCJyZXF1ZXN0X21ldGhvZCI6IlBPU1QifUq9AQoWYnJhaW50cnVzdC5vdXRwdXRfanNvbhKiAQqfAVt7ImluZGV4IjowLCJtZXNzYWdlIjp7InJvbGUiOiJhc3Npc3RhbnQiLCJjb250ZW50IjoiVGhlIGNhcGl0YWwgb2YgRnJhbmNlIGlzIFBhcmlzLiIsInJlZnVzYWwiOm51bGwsImFubm90YXRpb25zIjpbXX0sImxvZ3Byb2JzIjpudWxsLCJmaW5pc2hfcmVhc29uIjoic3RvcCJ9XXoAhQEBAQAA"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhN2uHhSoAMEM3A=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c35d-573d24920a8e4d8f7e132581;Parent=4f601250504b1256;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:06:38 GMT",
- "Via" : "1.1 b47176981720d8607d309e56e9510316.cloudfront.net (CloudFront), 1.1 ddea1c07643e5e0bfceb34480eebdc52.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c35d00000000051a2a8eee158398",
- "x-amzn-RequestId" : "06e89150-69a1-4102-8cfc-025e82aca34c",
- "X-Amz-Cf-Id" : "Q54hOT1Ri58CLG1Z3EpTEtSyM0b8UrHJ7Z_PGXVyGRvHfnBFxg6OOw==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "ecd72a15-bc56-4af7-8f3a-ea007535f361",
- "persistent" : true,
- "insertionIndex" : 161
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-f0e34c5f-d4f8-4895-9817-a3bcf742e1fc.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-f0e34c5f-d4f8-4895-9817-a3bcf742e1fc.json
deleted file mode 100644
index 5a069ab5..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-f0e34c5f-d4f8-4895-9817-a3bcf742e1fc.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "f0e34c5f-d4f8-4895-9817-a3bcf742e1fc",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CokICrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBLRBgoRCg9icmFpbnRydXN0LWphdmESuwYKEMwn97S8HLvmnIRF1DzMUz0SCFssm0PKX6i5Kg9DaGF0IENvbXBsZXRpb24wATllLAFeuX2kGEEi+zuLuX2kGEqsAQoTYnJhaW50cnVzdC5tZXRhZGF0YRKUAQqRAXsicHJvdmlkZXIiOiJvcGVuYWkiLCJyZXF1ZXN0X3BhdGgiOiJjaGF0L2NvbXBsZXRpb25zIiwibW9kZWwiOiJncHQtNG8tbWluaSIsInJlcXVlc3RfYmFzZV91cmkiOiJodHRwOi8vbG9jYWxob3N0OjM3MDA1IiwicmVxdWVzdF9tZXRob2QiOiJQT1NUIn1K1gEKFmJyYWludHJ1c3Qub3V0cHV0X2pzb24SuwEKuAFbeyJmaW5pc2hfcmVhc29uIjoic3RvcCIsImluZGV4IjowLCJsb2dwcm9icyI6bnVsbCwibWVzc2FnZSI6eyJjb250ZW50IjoiVGhlIGNhcGl0YWwgb2YgRnJhbmNlIGlzIFBhcmlzLiIsInJlZnVzYWwiOm51bGwsInJvbGUiOiJhc3Npc3RhbnQiLCJ0b29sX2NhbGxzIjpbXSwidmFsaWQiOnRydWV9LCJ2YWxpZCI6dHJ1ZX1dSi4KGmJyYWludHJ1c3Quc3Bhbl9hdHRyaWJ1dGVzEhAKDnsidHlwZSI6ImxsbSJ9SjIKEWJyYWludHJ1c3QucGFyZW50Eh0KG3Byb2plY3RfbmFtZTpqYXZhLXVuaXQtdGVzdEqRAQoVYnJhaW50cnVzdC5pbnB1dF9qc29uEngKdlt7ImNvbnRlbnQiOiJZb3UgYXJlIGEgaGVscGZ1bCBhc3Npc3RhbnQiLCJyb2xlIjoic3lzdGVtIn0seyJjb250ZW50IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBGcmFuY2U/Iiwicm9sZSI6InVzZXIifV1KcAoSYnJhaW50cnVzdC5tZXRyaWNzEloKWHsiY29tcGxldGlvbl90b2tlbnMiOjcsInByb21wdF90b2tlbnMiOjIzLCJ0b2tlbnMiOjMwLCJ0aW1lX3RvX2ZpcnN0X3Rva2VuIjowLjAwNTg2Nzc3M316AIUBAQEAAA=="
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhN1WFCJoAMEp1g=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c355-266d58197ae43abd15e69af8;Parent=174a5b581a595174;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:06:29 GMT",
- "Via" : "1.1 b7e07d6a19a4c8b2e410e9c1e173548c.cloudfront.net (CloudFront), 1.1 0eb43913f9caf453beb959a8a836a688.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c355000000002b0d88ae6c63ddab",
- "x-amzn-RequestId" : "f32da955-61be-4721-9fa4-feb6546d57a8",
- "X-Amz-Cf-Id" : "nExrtVA7erJcDIWe84Cm8evgccaZjfynoWY92PjUL-1poRuB62R3fg==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "f0e34c5f-d4f8-4895-9817-a3bcf742e1fc",
- "persistent" : true,
- "insertionIndex" : 152
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-f90a8bb2-65c9-4689-ae2e-0c41579fdb50.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-f90a8bb2-65c9-4689-ae2e-0c41579fdb50.json
deleted file mode 100644
index 896a75db..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-f90a8bb2-65c9-4689-ae2e-0c41579fdb50.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "f90a8bb2-65c9-4689-ae2e-0c41579fdb50",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNSREkFIAMEg_A=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c274-5b6691757a80bd224e753811;Parent=338de17c224bb32c;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:02:44 GMT",
- "Via" : "1.1 6281593da0ade6742b2f405f2b9ea0ba.cloudfront.net (CloudFront), 1.1 566cc276dff9847158a5a9854be4df42.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c27400000000223987baee674668",
- "x-amzn-RequestId" : "01fbac78-3a05-4d61-b3d6-c2cdbd6f86d9",
- "X-Amz-Cf-Id" : "8vA5DIneSkYyH6ZbEdvK7uIyzv0CcmYlAGKAnmPEiMGgus6hKaNCzw==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "f90a8bb2-65c9-4689-ae2e-0c41579fdb50",
- "persistent" : true,
- "insertionIndex" : 32
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-f983c72a-3478-41af-8c69-26a95933fc8d.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-f983c72a-3478-41af-8c69-26a95933fc8d.json
deleted file mode 100644
index a9d817ec..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-f983c72a-3478-41af-8c69-26a95933fc8d.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "f983c72a-3478-41af-8c69-26a95933fc8d",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "CuYJCrIBCiAKDHNlcnZpY2UubmFtZRIQCg5icmFpbnRydXN0LWFwcAoiCg9zZXJ2aWNlLnZlcnNpb24SDwoNMC4zLjAtMWMwNGFmMAogChZ0ZWxlbWV0cnkuc2RrLmxhbmd1YWdlEgYKBGphdmEKJQoSdGVsZW1ldHJ5LnNkay5uYW1lEg8KDW9wZW50ZWxlbWV0cnkKIQoVdGVsZW1ldHJ5LnNkay52ZXJzaW9uEggKBjEuNTkuMBKuCAoRCg9icmFpbnRydXN0LWphdmESmAgKEBjiCPM14ClaKyHM3pKkHGMSCMhiD0nDawh3KhBnZW5lcmF0ZV9jb250ZW50MAM5GXvqYrN9pBhBTxtDpbN9pBhKdQoTYnJhaW50cnVzdC5tZXRhZGF0YRJeClx7InByb3ZpZGVyIjoiZ2VtaW5pIiwidGVtcGVyYXR1cmUiOjAuMCwibW9kZWwiOiJnZW1pbmktMi4wLWZsYXNoLWxpdGUiLCJtYXhPdXRwdXRUb2tlbnMiOjUwfUraAwoWYnJhaW50cnVzdC5vdXRwdXRfanNvbhK/Awq8A3siY2FuZGlkYXRlcyI6W3siY29udGVudCI6eyJwYXJ0cyI6W3sidGV4dCI6IlRoZSBjYXBpdGFsIG9mIEdlcm1hbnkgaXMgQmVybGluLlxuIn1dLCJyb2xlIjoibW9kZWwifSwiZmluaXNoUmVhc29uIjoiU1RPUCIsImF2Z0xvZ3Byb2JzIjotMC4wNzgyNDM5NzA4NzA5NzE2OH1dLCJ1c2FnZU1ldGFkYXRhIjp7InByb21wdFRva2VuQ291bnQiOjcsImNhbmRpZGF0ZXNUb2tlbkNvdW50Ijo4LCJ0b3RhbFRva2VuQ291bnQiOjE1LCJwcm9tcHRUb2tlbnNEZXRhaWxzIjpbeyJtb2RhbGl0eSI6IlRFWFQiLCJ0b2tlbkNvdW50Ijo3fV0sImNhbmRpZGF0ZXNUb2tlbnNEZXRhaWxzIjpbeyJtb2RhbGl0eSI6IlRFWFQiLCJ0b2tlbkNvdW50Ijo4fV19LCJtb2RlbFZlcnNpb24iOiJnZW1pbmktMi4wLWZsYXNoLWxpdGUiLCJyZXNwb25zZUlkIjoiTzhQV2FiamtBOENlcXRzUG1LSzdnQVUifUoyChFicmFpbnRydXN0LnBhcmVudBIdChtwcm9qZWN0X25hbWU6amF2YS11bml0LXRlc3RKLgoaYnJhaW50cnVzdC5zcGFuX2F0dHJpYnV0ZXMSEAoOeyJ0eXBlIjoibGxtIn1KwgEKFWJyYWludHJ1c3QuaW5wdXRfanNvbhKoAQqlAXsiY29udGVudHMiOlt7InBhcnRzIjpbeyJ0ZXh0IjoiV2hhdCBpcyB0aGUgY2FwaXRhbCBvZiBHZXJtYW55PyJ9XSwicm9sZSI6InVzZXIifV0sIm1vZGVsIjoiZ2VtaW5pLTIuMC1mbGFzaC1saXRlIiwiY29uZmlnIjp7InRlbXBlcmF0dXJlIjowLjAsIm1heE91dHB1dFRva2VucyI6NTB9fUpNChJicmFpbnRydXN0Lm1ldHJpY3MSNwo1eyJjb21wbGV0aW9uX3Rva2VucyI6OCwicHJvbXB0X3Rva2VucyI6NywidG9rZW5zIjoxNX16AhgBhQEBAQAA"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNxcEnzoAMEVgA=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c33c-6cba6fc93201e09175660615;Parent=648b508ffa77f22b;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:06:04 GMT",
- "Via" : "1.1 d118b2ea8414d381f46f91331ab67f02.cloudfront.net (CloudFront), 1.1 da32b45f2cc22dc818960285c4e91b66.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c33c0000000036c1b531f8ccacef",
- "x-amzn-RequestId" : "7ceb5a91-3a20-41cf-8591-aa52587976bb",
- "X-Amz-Cf-Id" : "tRrVcXT3WPFaT7DV5968itNqKzKtOtAJjZmZrt1MrDORTXK49Qy1gw==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "f983c72a-3478-41af-8c69-26a95933fc8d",
- "persistent" : true,
- "insertionIndex" : 147
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-fc78d31e-39cf-4add-8cb5-365ed3658189.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-fc78d31e-39cf-4add-8cb5-365ed3658189.json
deleted file mode 100644
index 87dd0d9f..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-fc78d31e-39cf-4add-8cb5-365ed3658189.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "fc78d31e-39cf-4add-8cb5-365ed3658189",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "cqZkDFrmIAMENwA=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69f4094c-2d10cb1c1a2813ed5911d64a;Parent=0f28d3f26e4b10c4;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Fri, 01 May 2026 02:00:45 GMT",
- "Via" : "1.1 724581b48d733e53834b535d2a623034.cloudfront.net (CloudFront), 1.1 fbb003dfc0617e3e058e3dac791dfd5a.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69f4094c000000001e6a52a920029db4",
- "x-amzn-RequestId" : "1ddae7a9-6b6b-4d8e-820e-e10fb98bd7b0",
- "X-Amz-Cf-Id" : "S8PIcvl8lXZwXMts32FsRKL02D7tmEvYauQ89AjWc3KJRi0nceS95w==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "fc78d31e-39cf-4add-8cb5-365ed3658189",
- "persistent" : true,
- "insertionIndex" : 225
-}
\ No newline at end of file
diff --git a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-ff079568-19b8-47a9-9f4b-7dd1d20a1577.json b/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-ff079568-19b8-47a9-9f4b-7dd1d20a1577.json
deleted file mode 100644
index 6d96d033..00000000
--- a/test-harness/src/testFixtures/resources/cassettes/braintrust/mappings/otel_v1_traces-ff079568-19b8-47a9-9f4b-7dd1d20a1577.json
+++ /dev/null
@@ -1,39 +0,0 @@
-{
- "id" : "ff079568-19b8-47a9-9f4b-7dd1d20a1577",
- "name" : "otel_v1_traces",
- "request" : {
- "url" : "/otel/v1/traces",
- "method" : "POST",
- "headers" : {
- "Content-Type" : {
- "equalTo" : "application/x-protobuf"
- }
- },
- "bodyPatterns" : [ {
- "binaryEqualTo" : "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"
- } ]
- },
- "response" : {
- "status" : 200,
- "headers" : {
- "X-Cache" : "Miss from cloudfront",
- "x-amz-apigw-id" : "bhNQwExXIAMEkGQ=",
- "vary" : "Origin",
- "x-amzn-Remapped-content-length" : "0",
- "X-Amz-Cf-Pop" : [ "SEA900-P1", "SEA900-P10" ],
- "X-Amzn-Trace-Id" : "Root=1-69d6c26a-12485fa849651f9e7a66677e;Parent=0af696bd1c5449f9;Sampled=0;Lineage=1:24be3d11:0",
- "Date" : "Wed, 08 Apr 2026 21:02:35 GMT",
- "Via" : "1.1 b7e07d6a19a4c8b2e410e9c1e173548c.cloudfront.net (CloudFront), 1.1 0df7f27a01014ab815259ca2d88193c6.cloudfront.net (CloudFront)",
- "access-control-expose-headers" : "x-bt-cursor,x-bt-found-existing,x-bt-query-plan,x-bt-api-duration-ms,x-bt-brainstore-duration-ms,x-bt-internal-trace-id",
- "access-control-allow-credentials" : "true",
- "x-bt-internal-trace-id" : "69d6c26a00000000423e22a07542df83",
- "x-amzn-RequestId" : "ca27588d-4d46-4454-bb15-1c662872174a",
- "X-Amz-Cf-Id" : "O7wf13F98A2FSit6s2GevQxKnsQTrx2Mfr-IROy9MszJe7-F0_WpKQ==",
- "etag" : "W/\"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk\"",
- "Content-Type" : "application/x-protobuf"
- }
- },
- "uuid" : "ff079568-19b8-47a9-9f4b-7dd1d20a1577",
- "persistent" : true,
- "insertionIndex" : 57
-}
\ No newline at end of file