@mastra/langsmith 0.0.0-error-handler-fix-20251020202607 → 0.0.0-execa-dynamic-import-20260304221256

package/LICENSE.md

@@ -1,3 +1,18 @@
+Portions of this software are licensed as follows:
+
+- All content that resides under any directory named "ee/" within this
+  repository, including but not limited to:
+  - `packages/core/src/auth/ee/`
+  - `packages/server/src/server/auth/ee/`
+    is licensed under the license defined in `ee/LICENSE`.
+
+- All third-party components incorporated into the Mastra Software are
+  licensed under the original license provided by the owner of the
+  applicable component.
+
+- Content outside of the above-mentioned directories or restrictions is
+  available under the "Apache License 2.0" as defined below.
+
 # Apache License 2.0
 
 Copyright (c) 2025 Kepler Software, Inc.

package/README.md

@@ -10,21 +10,51 @@ npm install @mastra/langsmith
 
 ## Usage
 
+### Zero-Config Setup
+
+The exporter automatically reads credentials from environment variables:
+
+```bash
+# Required
+LANGSMITH_API_KEY=lsv2_pt_...
+
+# Optional
+LANGCHAIN_PROJECT=my-project  # Project name, defaults to "default"
+```
+
 ```typescript
 import { LangSmithExporter } from '@mastra/langsmith';
 
-// Set process.env.LANGSMITH_TRACING = "true";
+const mastra = new Mastra({
+  ...,
+  observability: {
+    configs: {
+      langsmith: {
+        serviceName: 'my-service',
+        exporters: [new LangSmithExporter()],
+      },
+    },
+  },
+});
+```
+
+### Explicit Configuration
+
+You can also pass credentials directly:
+
+```typescript
+import { LangSmithExporter } from '@mastra/langsmith';
 
-// Use with Mastra
 const mastra = new Mastra({
   ...,
   observability: {
     configs: {
       langsmith: {
-        serviceName: 'service',
+        serviceName: 'my-service',
         exporters: [
           new LangSmithExporter({
-            apiKey: process.env.LANGSMITH_API_KEY, // Defaults to process.env.LANGSMITH_API_KEY
+            apiKey: 'lsv2_pt_...',
+            projectName: 'my-custom-project', // Optional
           }),
         ],
       },
@@ -33,9 +63,18 @@ const mastra = new Mastra({
 });
 ```
 
+### Configuration Options
+
+| Option        | Type     | Description                                                                                |
+| ------------- | -------- | ------------------------------------------------------------------------------------------ |
+| `apiKey`      | `string` | LangSmith API key. Defaults to `LANGSMITH_API_KEY` env var                                 |
+| `projectName` | `string` | The name of the LangSmith project to send traces to. Overrides `LANGCHAIN_PROJECT` env var |
+| `apiUrl`      | `string` | Custom LangSmith API URL (for self-hosted instances)                                       |
+| `client`      | `Client` | Custom LangSmith client instance                                                           |
+
 ## Features
 
-### AI Tracing
+### Tracing
 
 - **Automatic span mapping**: Root spans become LangSmith traces
 - **Type-specific metadata**: Extracts relevant metadata for each span type (agents, tools, workflows)

package/dist/helpers.d.ts

@@ -0,0 +1,83 @@
+/**
+ * LangSmith Tracing Options Helpers
+ *
+ * These helpers integrate with the `buildTracingOptions` pattern from
+ * `@mastra/observability` to add LangSmith-specific tracing features.
+ *
+ * @example
+ * ```typescript
+ * import { buildTracingOptions } from '@mastra/observability';
+ * import { withLangsmithMetadata } from '@mastra/langsmith';
+ *
+ * const agent = new Agent({
+ *   defaultGenerateOptions: {
+ *     tracingOptions: buildTracingOptions(
+ *       withLangsmithMetadata({ projectName: 'my-project' })
+ *     ),
+ *   },
+ * });
+ * ```
+ */
+import type { TracingOptionsUpdater } from '@mastra/observability';
+/**
+ * LangSmith vendor metadata that can be passed via span metadata.
+ * These fields are extracted by the LangSmith exporter and used
+ * to override default configuration on a per-span basis.
+ */
+export interface LangSmithMetadataInput {
+    /**
+     * Override the project name for this span and its children.
+     * This allows dynamically routing traces to different LangSmith projects.
+     */
+    projectName?: string;
+    /**
+     * Session ID for grouping related traces in LangSmith.
+     */
+    sessionId?: string;
+    /**
+     * Session name for display in LangSmith.
+     */
+    sessionName?: string;
+}
+/**
+ * Adds LangSmith metadata to the tracing options.
+ *
+ * The metadata is added under `metadata.langsmith` and allows you to:
+ * - Route traces to different LangSmith projects via `projectName`
+ * - Group traces by session via `sessionId` and `sessionName`
+ *
+ * @param metadata - The LangSmith metadata to add
+ * @returns A TracingOptionsUpdater function for use with `buildTracingOptions`
+ *
+ * @example
+ * ```typescript
+ * import { buildTracingOptions } from '@mastra/observability';
+ * import { withLangsmithMetadata } from '@mastra/langsmith';
+ *
+ * // Route traces to a specific project
+ * const tracingOptions = buildTracingOptions(
+ *   withLangsmithMetadata({ projectName: 'customer-support' }),
+ * );
+ *
+ * // Or set multiple fields
+ * const tracingOptions = buildTracingOptions(
+ *   withLangsmithMetadata({
+ *     projectName: 'my-project',
+ *     sessionId: 'session-123',
+ *   }),
+ * );
+ *
+ * // Use in agent config
+ * const agent = new Agent({
+ *   name: 'support-agent',
+ *   model: openai('gpt-4o'),
+ *   defaultGenerateOptions: {
+ *     tracingOptions: buildTracingOptions(
+ *       withLangsmithMetadata({ projectName: 'support-traces' })
+ *     ),
+ *   },
+ * });
+ * ```
+ */
+export declare function withLangsmithMetadata(metadata: LangSmithMetadataInput): TracingOptionsUpdater;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAEnE;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,sBAAsB,GAAG,qBAAqB,CAW7F"}

package/dist/index.cjs

@@ -1,59 +1,65 @@
 'use strict';
 
-var aiTracing = require('@mastra/core/ai-tracing');
-var logger = require('@mastra/core/logger');
+var observability$1 = require('@mastra/core/observability');
+var utils = require('@mastra/core/utils');
+var observability = require('@mastra/observability');
 var langsmith = require('langsmith');
 
-// src/ai-tracing.ts
+// src/tracing.ts
 
 // src/metrics.ts
-function normalizeUsageMetrics(llmAttr) {
+function formatUsageMetrics(usage) {
   const metrics = {};
-  if (llmAttr.usage?.inputTokens !== void 0) {
-    metrics.input_tokens = llmAttr.usage?.inputTokens;
-  } else if (llmAttr.usage?.promptTokens !== void 0) {
-    metrics.input_tokens = llmAttr.usage?.promptTokens;
+  if (usage?.inputTokens !== void 0) {
+    metrics.input_tokens = usage.inputTokens;
   }
-  if (llmAttr.usage?.outputTokens !== void 0) {
-    metrics.output_tokens = llmAttr.usage?.outputTokens;
-  } else if (llmAttr.usage?.completionTokens !== void 0) {
-    metrics.output_tokens = llmAttr.usage?.completionTokens;
+  if (usage?.outputTokens !== void 0) {
+    metrics.output_tokens = usage.outputTokens;
   }
-  if (llmAttr.usage?.totalTokens !== void 0) {
-    metrics.total_tokens = llmAttr.usage?.totalTokens;
-  } else if (typeof llmAttr.usage?.inputTokens === "number" && typeof llmAttr.usage?.outputTokens === "number") {
-    metrics.total_tokens = llmAttr.usage?.inputTokens + llmAttr.usage?.outputTokens;
+  if (metrics.input_tokens !== void 0 && metrics.output_tokens !== void 0) {
+    metrics.total_tokens = metrics.input_tokens + metrics.output_tokens;
   }
-  if (llmAttr.usage?.reasoningTokens !== void 0) {
+  if (usage?.outputDetails?.reasoning !== void 0) {
     metrics.output_token_details = {
       ...metrics.output_token_details ?? {},
-      reasoning_tokens: llmAttr.usage?.reasoningTokens
+      reasoning_tokens: usage.outputDetails.reasoning
     };
   }
-  if (llmAttr.usage?.promptCacheHitTokens !== void 0) {
+  if (usage?.inputDetails?.cacheRead !== void 0) {
     metrics.input_token_details = {
       ...metrics.input_token_details ?? {},
-      cache_read: llmAttr.usage?.promptCacheHitTokens
+      cache_read: usage.inputDetails.cacheRead
     };
   }
-  if (llmAttr.usage?.promptCacheMissTokens !== void 0) {
+  if (usage?.inputDetails?.cacheWrite !== void 0) {
     metrics.input_token_details = {
       ...metrics.input_token_details ?? {},
-      cache_write: llmAttr.usage?.promptCacheMissTokens
+      cache_write: usage.inputDetails.cacheWrite
+    };
+  }
+  if (usage?.inputDetails?.audio !== void 0) {
+    metrics.input_token_details = {
+      ...metrics.input_token_details ?? {},
+      audio: usage.inputDetails.audio
+    };
+  }
+  if (usage?.outputDetails?.audio !== void 0) {
+    metrics.output_token_details = {
+      ...metrics.output_token_details ?? {},
+      audio: usage.outputDetails.audio
     };
   }
   return metrics;
 }
 
-// src/ai-tracing.ts
+// src/tracing.ts
 var DEFAULT_SPAN_TYPE = "chain";
 var SPAN_TYPE_EXCEPTIONS = {
-  [aiTracing.AISpanType.LLM_GENERATION]: "llm",
-  [aiTracing.AISpanType.LLM_CHUNK]: "llm",
-  [aiTracing.AISpanType.TOOL_CALL]: "tool",
-  [aiTracing.AISpanType.MCP_TOOL_CALL]: "tool",
-  [aiTracing.AISpanType.WORKFLOW_CONDITIONAL_EVAL]: "chain",
-  [aiTracing.AISpanType.WORKFLOW_WAIT_EVENT]: "chain"
+  [observability$1.SpanType.MODEL_GENERATION]: "llm",
+  [observability$1.SpanType.TOOL_CALL]: "tool",
+  [observability$1.SpanType.MCP_TOOL_CALL]: "tool",
+  [observability$1.SpanType.WORKFLOW_CONDITIONAL_EVAL]: "chain",
+  [observability$1.SpanType.WORKFLOW_WAIT_EVENT]: "chain"
 };
 function mapSpanType(spanType) {
   return SPAN_TYPE_EXCEPTIONS[spanType] ?? DEFAULT_SPAN_TYPE;
@@ -61,203 +67,164 @@ function mapSpanType(spanType) {
 function isKVMap(value) {
   return value != null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
 }
-var LangSmithExporter = class {
+var LangSmithExporter = class extends observability.TrackingExporter {
   name = "langsmith";
-  traceMap = /* @__PURE__ */ new Map();
-  logger;
-  config;
-  client;
-  constructor(config) {
-    this.logger = new logger.ConsoleLogger({ level: config.logLevel ?? "warn" });
-    config.apiKey = config.apiKey ?? process.env.LANGSMITH_API_KEY;
-    if (!config.apiKey) {
-      this.logger.error("LangSmithExporter: Missing required credentials, exporter will be disabled", {
-        hasApiKey: !!config.apiKey
-      });
-      this.config = null;
-      this.client = null;
-      return;
-    }
-    this.client = config.client ?? new langsmith.Client(config);
-    this.config = config;
-  }
-  async exportEvent(event) {
-    if (!this.config) {
-      return;
-    }
-    if (event.exportedSpan.isEvent) {
-      await this.handleEventSpan(event.exportedSpan);
+  #client;
+  constructor(config = {}) {
+    const apiKey = config.apiKey ?? process.env.LANGSMITH_API_KEY;
+    super({
+      ...config,
+      apiKey
+    });
+    if (!apiKey) {
+      this.setDisabled(`Missing required credentials (apiKey: ${!!apiKey})`);
       return;
     }
-    switch (event.type) {
-      case "span_started":
-        await this.handleSpanStarted(event.exportedSpan);
-        break;
-      case "span_updated":
-        await this.handleSpanUpdateOrEnd(event.exportedSpan, false);
-        break;
-      case "span_ended":
-        await this.handleSpanUpdateOrEnd(event.exportedSpan, true);
-        break;
-    }
+    this.#client = config.client ?? new langsmith.Client(this.config);
   }
-  initializeRootSpan(span) {
-    this.traceMap.set(span.traceId, { spans: /* @__PURE__ */ new Map(), activeIds: /* @__PURE__ */ new Set() });
+  skipBuildRootTask = true;
+  async _buildRoot(_args) {
+    throw new Error("Method not implemented.");
   }
-  async handleSpanStarted(span) {
-    this.logger.debug("LangSmith exporter: handleSpanStarted", span.id, span.name);
-    if (span.isRootSpan) {
-      this.initializeRootSpan(span);
-    }
-    const method = "handleSpanStarted";
-    const spanData = this.getSpanData({ span, method });
-    if (!spanData) {
+  async _buildSpan(args) {
+    const { span, traceData } = args;
+    const parent = span.isRootSpan ? void 0 : traceData.getParent(args);
+    if (!span.isRootSpan && !parent) {
       return;
     }
-    if (!span.isEvent) {
-      spanData.activeIds.add(span.id);
-    }
     const payload = {
       name: span.name,
-      run_type: mapSpanType(span.type),
-      ...this.buildRunTreePayload(span)
+      ...this.buildRunTreePayload(span, traceData, true)
     };
-    const langsmithParent = this.getLangSmithParent({ spanData, span, method });
-    let langsmithRunTree;
-    if (!langsmithParent) {
-      langsmithRunTree = new langsmith.RunTree(payload);
-    } else {
-      langsmithRunTree = langsmithParent.createChild(payload);
-    }
-    spanData.spans.set(span.id, langsmithRunTree);
-    await langsmithRunTree.postRun();
+    const langSmithSpan = span.isRootSpan ? new langsmith.RunTree(payload) : parent.createChild(payload);
+    await langSmithSpan.postRun();
+    return langSmithSpan;
   }
-  async handleSpanUpdateOrEnd(span, isEnd) {
-    this.logger.debug("LangSmith exporter: handleSpanUpdateOrEnd", span.id, span.name, "isEnd:", isEnd);
-    const method = isEnd ? "handleSpanEnd" : "handleSpanUpdate";
-    const spanData = this.getSpanData({ span, method });
-    if (!spanData) {
+  async _buildEvent(args) {
+    const langSmithSpan = await this._buildSpan(args);
+    if (!langSmithSpan) {
       return;
     }
-    const langsmithRunTree = spanData.spans.get(span.id);
-    if (!langsmithRunTree) {
-      this.logger.warn("LangSmith exporter: No LangSmith span found for span update/end", {
-        traceId: span.traceId,
-        spanId: span.id,
-        spanName: span.name,
-        spanType: span.type,
-        isRootSpan: span.isRootSpan,
-        parentSpanId: span.parentSpanId,
-        method
-      });
+    await langSmithSpan.end({ endTime: args.span.startTime.getTime() });
+    await langSmithSpan.patchRun();
+    return langSmithSpan;
+  }
+  async _updateSpan(args) {
+    await this.handleSpanUpdateOrEnd({ ...args, isEnd: false });
+  }
+  async _finishSpan(args) {
+    await this.handleSpanUpdateOrEnd({ ...args, isEnd: true });
+  }
+  async _abortSpan(args) {
+    const { span, reason } = args;
+    span.error = reason.message;
+    span.metadata = {
+      ...span.metadata,
+      errorDetails: reason
+    };
+    await span.end();
+    await span.patchRun();
+  }
+  async handleSpanUpdateOrEnd(args) {
+    const { span, traceData, isEnd } = args;
+    const langSmithSpan = traceData.getSpan({ spanId: span.id });
+    if (!langSmithSpan) {
       return;
     }
-    const updatePayload = this.buildRunTreePayload(span);
-    langsmithRunTree.metadata = {
-      ...langsmithRunTree.metadata,
+    const updatePayload = this.buildRunTreePayload(span, traceData);
+    langSmithSpan.metadata = {
+      ...langSmithSpan.metadata,
       ...updatePayload.metadata
     };
     if (updatePayload.inputs != null) {
-      langsmithRunTree.inputs = updatePayload.inputs;
+      langSmithSpan.inputs = updatePayload.inputs;
     }
     if (updatePayload.outputs != null) {
-      langsmithRunTree.outputs = updatePayload.outputs;
+      langSmithSpan.outputs = updatePayload.outputs;
     }
     if (updatePayload.error != null) {
-      langsmithRunTree.error = updatePayload.error;
+      langSmithSpan.error = updatePayload.error;
+    }
+    if (span.type === observability$1.SpanType.MODEL_GENERATION) {
+      const modelAttr = span.attributes ?? {};
+      if (modelAttr.completionStartTime !== void 0) {
+        langSmithSpan.addEvent({
+          name: "new_token",
+          time: modelAttr.completionStartTime.toISOString()
+        });
+      }
     }
     if (isEnd) {
       if (span.endTime) {
-        await langsmithRunTree.end({ endTime: span.endTime.getTime() / 1e3 });
+        await langSmithSpan.end({ endTime: span.endTime.getTime() });
       } else {
-        await langsmithRunTree.end();
-      }
-      await langsmithRunTree.patchRun();
-      if (!span.isEvent) {
-        spanData.activeIds.delete(span.id);
-      }
-      if (spanData.activeIds.size === 0) {
-        this.traceMap.delete(span.traceId);
+        await langSmithSpan.end();
       }
     }
+    await langSmithSpan.patchRun();
   }
-  async handleEventSpan(span) {
-    if (span.isRootSpan) {
-      this.logger.debug("LangSmith exporter: Creating logger for event", {
-        traceId: span.traceId,
-        spanId: span.id,
-        spanName: span.name,
-        method: "handleEventSpan"
-      });
-      this.initializeRootSpan(span);
-    }
-    const method = "handleEventSpan";
-    const spanData = this.getSpanData({ span, method });
-    if (!spanData) {
-      return;
-    }
-    const langsmithParent = this.getLangSmithParent({ spanData, span, method });
-    const payload = {
-      ...this.buildRunTreePayload(span),
-      name: span.name,
-      type: mapSpanType(span.type),
-      startTime: span.startTime.getTime() / 1e3
-    };
-    let langsmithRunTree;
-    if (!langsmithParent) {
-      langsmithRunTree = new langsmith.RunTree(payload);
-    } else {
-      langsmithRunTree = langsmithParent.createChild(payload);
-    }
-    await langsmithRunTree.postRun();
-    await langsmithRunTree.end({ endTime: span.startTime.getTime() / 1e3 });
-    await langsmithRunTree.patchRun();
-  }
-  getSpanData(options) {
-    const { span, method } = options;
-    if (this.traceMap.has(span.traceId)) {
-      return this.traceMap.get(span.traceId);
+  /**
+   * Find LangSmith vendor metadata by walking up the span hierarchy and merging.
+   * Metadata is merged from ancestors with child values taking precedence over parent values.
+   *
+   * TODO(2.0): Extract shared `findVendorMetadata()` to base TrackingExporter class
+   * and reuse here and in LangfuseExporter.findLangfusePrompt()
+   */
+  findLangsmithMetadata(traceData, span) {
+    const metadataChain = [];
+    let currentSpanId = span.id;
+    while (currentSpanId) {
+      const providerMetadata = traceData.getMetadata({ spanId: currentSpanId });
+      if (providerMetadata) {
+        metadataChain.push(providerMetadata);
+      }
+      currentSpanId = traceData.getParentId({ spanId: currentSpanId });
     }
-    this.logger.warn("LangSmith exporter: No span data found for span", {
-      traceId: span.traceId,
-      spanId: span.id,
-      spanName: span.name,
-      spanType: span.type,
-      isRootSpan: span.isRootSpan,
-      parentSpanId: span.parentSpanId,
-      method
-    });
-  }
-  getLangSmithParent(options) {
-    const { spanData, span, method } = options;
-    const parentId = span.parentSpanId;
-    if (!parentId) {
+    if (metadataChain.length === 0) {
       return void 0;
     }
-    if (spanData.spans.has(parentId)) {
-      return spanData.spans.get(parentId);
+    const merged = {};
+    for (let i = metadataChain.length - 1; i >= 0; i--) {
+      const meta = metadataChain[i];
+      if (meta.projectName !== void 0) merged.projectName = meta.projectName;
+      if (meta.sessionId !== void 0) merged.sessionId = meta.sessionId;
+      if (meta.sessionName !== void 0) merged.sessionName = meta.sessionName;
     }
-    if (parentId && !spanData.spans.has(parentId)) {
-      return void 0;
-    }
-    this.logger.warn("LangSmith exporter: No parent data found for span", {
+    this.logger.debug(`${this.name}: merged vendor metadata from hierarchy`, {
       traceId: span.traceId,
       spanId: span.id,
-      spanName: span.name,
-      spanType: span.type,
-      isRootSpan: span.isRootSpan,
-      parentSpanId: span.parentSpanId,
-      method
+      metadataKeys: Object.keys(merged),
+      ancestorCount: metadataChain.length
     });
+    return merged;
   }
-  buildRunTreePayload(span) {
+  buildRunTreePayload(span, traceData, isNew = false) {
+    const vendorMetadata = this.findLangsmithMetadata(traceData, span);
+    const spanMetadata = span.metadata ? utils.omitKeys(span.metadata, ["langsmith"]) : {};
     const payload = {
-      client: this.client,
+      client: this.#client,
       metadata: {
         mastra_span_type: span.type,
-        ...span.metadata
+        ...spanMetadata
       }
     };
+    if (isNew) {
+      payload.run_type = mapSpanType(span.type);
+      payload.start_time = span.startTime.getTime();
+    }
+    const projectName = vendorMetadata?.projectName ?? this.config.projectName;
+    if (projectName) {
+      payload.project_name = projectName;
+    }
+    if (vendorMetadata?.sessionId) {
+      payload.metadata.session_id = vendorMetadata.sessionId;
+    }
+    if (vendorMetadata?.sessionName) {
+      payload.metadata.session_name = vendorMetadata.sessionName;
+    }
+    if (span.isRootSpan && span.tags?.length) {
+      payload.tags = span.tags;
+    }
     if (span.input !== void 0) {
       payload.inputs = isKVMap(span.input) ? span.input : { input: span.input };
     }
@@ -265,19 +232,19 @@ var LangSmithExporter = class {
       payload.outputs = isKVMap(span.output) ? span.output : { output: span.output };
     }
     const attributes = span.attributes ?? {};
-    if (span.type === aiTracing.AISpanType.LLM_GENERATION) {
-      const llmAttr = attributes;
-      if (llmAttr.model !== void 0) {
-        payload.metadata.ls_model_name = llmAttr.model;
+    if (span.type === observability$1.SpanType.MODEL_GENERATION) {
+      const modelAttr = attributes;
+      if (modelAttr.model !== void 0) {
+        payload.metadata.ls_model_name = modelAttr.model;
       }
-      if (llmAttr.provider !== void 0) {
-        payload.metadata.ls_provider = llmAttr.provider;
+      if (modelAttr.provider !== void 0) {
+        payload.metadata.ls_provider = modelAttr.provider;
       }
-      payload.metadata.usage_metadata = normalizeUsageMetrics(llmAttr);
-      if (llmAttr.parameters !== void 0) {
-        payload.metadata.modelParameters = llmAttr.parameters;
+      payload.metadata.usage_metadata = formatUsageMetrics(modelAttr.usage);
+      if (modelAttr.parameters !== void 0) {
+        payload.metadata.modelParameters = modelAttr.parameters;
       }
-      const otherAttributes = aiTracing.omitKeys(attributes, ["model", "usage", "parameters"]);
+      const otherAttributes = utils.omitKeys(attributes, ["model", "provider", "usage", "parameters", "completionStartTime"]);
       payload.metadata = {
         ...payload.metadata,
         ...otherAttributes
@@ -294,20 +261,23 @@ var LangSmithExporter = class {
     }
     return payload;
   }
-  async shutdown() {
-    if (!this.config) {
-      return;
-    }
-    for (const [_traceId, spanData] of this.traceMap) {
-      for (const [_spanId, runTree] of spanData.spans) {
-        await runTree.end();
-        await runTree.patchRun();
+};
+
+// src/helpers.ts
+function withLangsmithMetadata(metadata) {
+  return (opts) => ({
+    ...opts,
+    metadata: {
+      ...opts.metadata,
+      langsmith: {
+        ...opts.metadata?.langsmith,
+        ...metadata
       }
     }
-    this.traceMap.clear();
-  }
-};
+  });
+}
 
 exports.LangSmithExporter = LangSmithExporter;
+exports.withLangsmithMetadata = withLangsmithMetadata;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map