langwatch 0.32.0 → 0.33.1

package/dist/chunk-5NL7Q33G.mjs

@@ -0,0 +1,512 @@
+import {
+  LangWatchLogsExporter,
+  LangWatchTraceExporter,
+  setLangWatchLoggerProvider
+} from "./chunk-KN453H3V.mjs";
+import {
+  DEFAULT_ENDPOINT,
+  DEFAULT_SERVICE_NAME,
+  LANGWATCH_SDK_LANGUAGE,
+  LANGWATCH_SDK_NAME_OBSERVABILITY,
+  LANGWATCH_SDK_VERSION
+} from "./chunk-E5DGXSL2.mjs";
+import {
+  initializeObservabilitySdkConfig
+} from "./chunk-JOLGDU7Q.mjs";
+import {
+  ATTR_LANGWATCH_SDK_LANGUAGE,
+  ATTR_LANGWATCH_SDK_NAME,
+  ATTR_LANGWATCH_SDK_VERSION,
+  ConsoleLogger
+} from "./chunk-GVFRS2UN.mjs";
+import {
+  __spreadValues
+} from "./chunk-BAX4W3AY.mjs";
+
+// src/observability-sdk/setup/node/setup.ts
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { SimpleLogRecordProcessor, BatchLogRecordProcessor, ConsoleLogRecordExporter, LoggerProvider } from "@opentelemetry/sdk-logs";
+
+// src/observability-sdk/setup/utils.ts
+import {
+  defaultResource,
+  resourceFromAttributes
+} from "@opentelemetry/resources";
+import * as semconv from "@opentelemetry/semantic-conventions/incubating";
+function createMergedResource(attributes, serviceName, givenResource) {
+  const langwatchResource = resourceFromAttributes({
+    [ATTR_LANGWATCH_SDK_NAME]: LANGWATCH_SDK_NAME_OBSERVABILITY,
+    [ATTR_LANGWATCH_SDK_LANGUAGE]: LANGWATCH_SDK_LANGUAGE,
+    [ATTR_LANGWATCH_SDK_VERSION]: LANGWATCH_SDK_VERSION
+  });
+  const userResource = resourceFromAttributes(__spreadValues({
+    [semconv.ATTR_SERVICE_NAME]: serviceName != null ? serviceName : DEFAULT_SERVICE_NAME
+  }, attributes != null ? attributes : {}));
+  return (givenResource != null ? givenResource : defaultResource()).merge(langwatchResource).merge(userResource);
+}
+function hasAttachableProcessorRegistry(obj) {
+  var _a, _b;
+  if (!obj || typeof obj !== "object") return false;
+  const candidates = [
+    (_a = obj == null ? void 0 : obj._activeSpanProcessor) == null ? void 0 : _a._spanProcessors,
+    (_b = obj == null ? void 0 : obj.activeSpanProcessor) == null ? void 0 : _b._spanProcessors,
+    obj == null ? void 0 : obj._registeredSpanProcessors
+  ];
+  return candidates.some(Array.isArray);
+}
+function getConcreteProvider(provider) {
+  var _a, _b;
+  if (!provider || typeof provider !== "object") return void 0;
+  const constructorName = (_a = provider.constructor) == null ? void 0 : _a.name;
+  if (["NodeTracerProvider", "BasicTracerProvider"].includes(constructorName)) {
+    return provider;
+  }
+  if (typeof provider.addSpanProcessor === "function") {
+    return provider;
+  }
+  if (hasAttachableProcessorRegistry(provider)) {
+    return provider;
+  }
+  let delegate;
+  if (typeof provider.getDelegate === "function") {
+    delegate = provider.getDelegate();
+  } else if (provider.delegate) {
+    delegate = provider.delegate;
+  } else if (provider._delegate) {
+    delegate = provider._delegate;
+  }
+  if (delegate && typeof delegate === "object") {
+    const delegateConstructorName = (_b = delegate.constructor) == null ? void 0 : _b.name;
+    if (["NodeTracerProvider", "BasicTracerProvider"].includes(delegateConstructorName)) {
+      return delegate;
+    }
+    if (typeof delegate.addSpanProcessor === "function") {
+      return delegate;
+    }
+    if (hasAttachableProcessorRegistry(delegate)) {
+      return delegate;
+    }
+  }
+  return void 0;
+}
+function isConcreteProvider(provider) {
+  return !!getConcreteProvider(provider);
+}
+
+// src/observability-sdk/setup/node/setup.ts
+import { trace } from "@opentelemetry/api";
+import {
+  ConsoleSpanExporter,
+  SimpleSpanProcessor,
+  BatchSpanProcessor
+} from "@opentelemetry/sdk-trace-base";
+import { registerInstrumentations } from "@opentelemetry/instrumentation";
+var createNoOpHandle = (logger) => ({
+  shutdown: async () => {
+    logger.debug("Shutdown called for LangWatch no-op. Nothing will be shutdown");
+  }
+});
+var getLangWatchConfig = (options) => {
+  var _a, _b, _c, _d;
+  const isDisabled = options.langwatch === "disabled";
+  const config = typeof options.langwatch === "object" ? options.langwatch : {};
+  return {
+    disabled: isDisabled,
+    apiKey: isDisabled ? void 0 : (_a = config.apiKey) != null ? _a : process.env.LANGWATCH_API_KEY,
+    endpoint: isDisabled ? void 0 : (_c = (_b = config.endpoint) != null ? _b : process.env.LANGWATCH_ENDPOINT) != null ? _c : DEFAULT_ENDPOINT,
+    processorType: (_d = config.processorType) != null ? _d : "batch"
+  };
+};
+var checkForEarlyExit = (options, logger) => {
+  var _a, _b;
+  const globalProvider = trace.getTracerProvider();
+  const alreadySetup = isConcreteProvider(globalProvider);
+  if (alreadySetup && !((_a = options.advanced) == null ? void 0 : _a.UNSAFE_forceOpenTelemetryReinitialization)) {
+    if ((_b = options.advanced) == null ? void 0 : _b.attachToExistingProvider) {
+      return null;
+    }
+    logger.error(
+      `OpenTelemetry is already set up in this process.
+Spans will NOT be sent to LangWatch unless you add the LangWatch span processor or exporter to your existing OpenTelemetry setup.
+You must either:
+  1. Remove your existing OpenTelemetry setup and only use LangWatch,
+  2. Add the LangWatch span processor to your existing setup, or replace the existing exporter with the LangWatch exporter.
+  3. Use advanced.attachToExistingProvider to let LangWatch attach its processors to the existing provider.
+
+For step-by-step instructions, see the LangWatch docs and check out the integration guide for your framework:
+  https://docs.langwatch.ai/integration/typescript/guide
+
+See also: https://github.com/open-telemetry/opentelemetry-js/issues/5299`
+    );
+    return createNoOpHandle(logger);
+  }
+  if (alreadySetup) {
+    logger.warn(
+      "OpenTelemetry is already set up, but UNSAFE_forceOpenTelemetryReinitialization=true. Proceeding with reinitialization. This may cause conflicts."
+    );
+  }
+  return null;
+};
+var warnIfMisconfigured = (options, langwatch, logger) => {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+  if (langwatch.disabled) {
+    const hasAlternativeExport = (_h = (_g = (_e = (_c = (_a = options.spanProcessors) == null ? void 0 : _a.length) != null ? _c : (_b = options.logRecordProcessors) == null ? void 0 : _b.length) != null ? _e : (_d = options.debug) == null ? void 0 : _d.consoleTracing) != null ? _g : (_f = options.debug) == null ? void 0 : _f.consoleLogging) != null ? _h : options.traceExporter;
+    if (!hasAlternativeExport) {
+      const errorMessage = "LangWatch integration is disabled but no custom span processors, trace exporters, or console tracing is configured. OpenTelemetry will be set up but traces will not be exported anywhere. Either:\n  1. Enable LangWatch integration (remove langwatch: 'disabled')\n  2. Provide custom spanProcessors, logRecordProcessors, or traceExporter\n  3. Enable debug.consoleTracing or debug.consoleLogging for development\n  4. Use advanced.disabled to completely disable observability\n  5. Use advanced.skipOpenTelemetrySetup to handle OpenTelemetry setup yourself";
+      if ((_i = options.advanced) == null ? void 0 : _i.throwOnSetupError) {
+        throw new Error(errorMessage);
+      } else {
+        logger.error(errorMessage);
+      }
+    }
+  }
+};
+function setupObservability(options = {}) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  const logger = (_d = (_a = options.debug) == null ? void 0 : _a.logger) != null ? _d : new ConsoleLogger({
+    level: (_c = (_b = options.debug) == null ? void 0 : _b.logLevel) != null ? _c : "warn",
+    prefix: "LangWatch Observability SDK"
+  });
+  initializeObservabilitySdkConfig({
+    logger,
+    dataCapture: options.dataCapture
+  });
+  if ((_e = options.advanced) == null ? void 0 : _e.disabled) {
+    logger.debug("Observability disabled via advanced.disabled");
+    return createNoOpHandle(logger);
+  }
+  if ((_f = options.advanced) == null ? void 0 : _f.skipOpenTelemetrySetup) {
+    logger.debug("Skipping OpenTelemetry setup");
+    return createNoOpHandle(logger);
+  }
+  if (options.tracerProvider) {
+    try {
+      return setupDedicatedProvider(options.tracerProvider, options, logger);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      logger.error(`Failed to set up dedicated provider: ${errorMessage}`);
+      if ((_g = options.advanced) == null ? void 0 : _g.throwOnSetupError) throw err;
+      return createNoOpHandle(logger);
+    }
+  }
+  const earlyExit = checkForEarlyExit(options, logger);
+  if (earlyExit) return earlyExit;
+  try {
+    const globalProvider = trace.getTracerProvider();
+    const existingProvider = getConcreteProvider(globalProvider);
+    if (((_h = options.advanced) == null ? void 0 : _h.attachToExistingProvider) && existingProvider) {
+      const handle = attachToExistingProvider(existingProvider, options, logger);
+      if (handle) return handle;
+      const errorMsg = "attachToExistingProvider is enabled but the existing provider does not support adding span processors. This may be due to an incompatible OpenTelemetry version. No spans will be exported to LangWatch.";
+      if ((_i = options.advanced) == null ? void 0 : _i.throwOnSetupError) throw new Error(errorMsg);
+      logger.error(errorMsg);
+      return createNoOpHandle(logger);
+    }
+    const sdk = createAndStartNodeSdk(options, logger, createMergedResource(
+      options.attributes,
+      options.serviceName,
+      options.resource
+    ));
+    logger.info("LangWatch Observability SDK setup completed successfully");
+    return {
+      shutdown: async () => {
+        logger.debug("Shutting down NodeSDK");
+        await (sdk == null ? void 0 : sdk.shutdown());
+        logger.info("NodeSDK shutdown complete");
+      }
+    };
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    logger.error(`Failed to initialize NodeSDK: ${errorMessage}`);
+    if (err instanceof Error && err.stack) {
+      logger.debug(`Stack trace: ${err.stack}`);
+    }
+    if ((_j = options.advanced) == null ? void 0 : _j.throwOnSetupError) throw err;
+    return createNoOpHandle(logger);
+  }
+}
+function setupDedicatedProvider(provider, options, logger) {
+  var _a, _b, _c, _d;
+  const langwatch = getLangWatchConfig(options);
+  const addedProcessors = [];
+  const internalArray = (_a = provider == null ? void 0 : provider._activeSpanProcessor) == null ? void 0 : _a._spanProcessors;
+  const hasPublicApi = typeof (provider == null ? void 0 : provider.addSpanProcessor) === "function";
+  if (!Array.isArray(internalArray) && !hasPublicApi) {
+    const msg = "Dedicated tracerProvider does not support adding span processors.";
+    if ((_b = options.advanced) == null ? void 0 : _b.throwOnSetupError) throw new Error(msg);
+    logger.error(msg);
+    return createNoOpHandle(logger);
+  }
+  const addProcessor = (processor) => {
+    if (hasPublicApi) {
+      provider.addSpanProcessor(processor);
+    } else {
+      internalArray.push(processor);
+    }
+  };
+  if (!langwatch.disabled) {
+    const traceExporter = new LangWatchTraceExporter({
+      apiKey: langwatch.apiKey,
+      endpoint: langwatch.endpoint
+    });
+    const processor = langwatch.processorType === "batch" ? new BatchSpanProcessor(traceExporter) : new SimpleSpanProcessor(traceExporter);
+    addedProcessors.push(processor);
+    addProcessor(processor);
+    logger.info("Attached LangWatch span processor to dedicated provider");
+  }
+  if (options.traceExporter) {
+    const p = new SimpleSpanProcessor(options.traceExporter);
+    addedProcessors.push(p);
+    addProcessor(p);
+  }
+  if ((_c = options.spanProcessors) == null ? void 0 : _c.length) {
+    for (const p of options.spanProcessors) {
+      addedProcessors.push(p);
+      addProcessor(p);
+    }
+  }
+  let unregisterInstrumentations;
+  if ((_d = options.instrumentations) == null ? void 0 : _d.length) {
+    unregisterInstrumentations = registerInstrumentations({
+      tracerProvider: provider,
+      instrumentations: options.instrumentations
+    });
+    logger.info(`Registered ${options.instrumentations.length} instrumentations against dedicated provider`);
+  }
+  logger.info("LangWatch Observability SDK setup completed with dedicated provider (trace-only, global provider untouched)");
+  return {
+    shutdown: async () => {
+      var _a2, _b2;
+      logger.debug("Shutting down dedicated LangWatch processors");
+      try {
+        await Promise.all(addedProcessors.map((p) => p.shutdown()));
+      } finally {
+        const candidates = [
+          (_a2 = provider == null ? void 0 : provider._activeSpanProcessor) == null ? void 0 : _a2._spanProcessors,
+          (_b2 = provider == null ? void 0 : provider.activeSpanProcessor) == null ? void 0 : _b2._spanProcessors,
+          provider == null ? void 0 : provider._registeredSpanProcessors
+        ];
+        for (const arr of candidates) {
+          if (!Array.isArray(arr)) continue;
+          for (const p of addedProcessors) {
+            const idx = arr.indexOf(p);
+            if (idx !== -1) arr.splice(idx, 1);
+          }
+        }
+        unregisterInstrumentations == null ? void 0 : unregisterInstrumentations();
+      }
+      logger.info("LangWatch processor shutdown complete");
+    }
+  };
+}
+function attachToExistingProvider(provider, options, logger) {
+  var _a, _b;
+  const internalArray = (_a = provider == null ? void 0 : provider._activeSpanProcessor) == null ? void 0 : _a._spanProcessors;
+  const hasPublicApi = typeof (provider == null ? void 0 : provider.addSpanProcessor) === "function";
+  if (!Array.isArray(internalArray) && !hasPublicApi) {
+    return null;
+  }
+  const addProcessor = (processor) => {
+    if (hasPublicApi) {
+      provider.addSpanProcessor(processor);
+    } else {
+      internalArray.push(processor);
+    }
+  };
+  const langwatch = getLangWatchConfig(options);
+  const addedProcessors = [];
+  if (!langwatch.disabled) {
+    const traceExporter = new LangWatchTraceExporter({
+      apiKey: langwatch.apiKey,
+      endpoint: langwatch.endpoint
+    });
+    const processor = langwatch.processorType === "batch" ? new BatchSpanProcessor(traceExporter) : new SimpleSpanProcessor(traceExporter);
+    addedProcessors.push(processor);
+    addProcessor(processor);
+    logger.info("Attached LangWatch span processor to existing global provider");
+  }
+  if (options.traceExporter) {
+    const traceExporterProcessor = new SimpleSpanProcessor(options.traceExporter);
+    addedProcessors.push(traceExporterProcessor);
+    addProcessor(traceExporterProcessor);
+    logger.debug("Attached user-provided traceExporter to existing provider");
+  }
+  if ((_b = options.spanProcessors) == null ? void 0 : _b.length) {
+    for (const processor of options.spanProcessors) {
+      addedProcessors.push(processor);
+      addProcessor(processor);
+    }
+    logger.debug(`Attached ${options.spanProcessors.length} user-provided span processors to existing provider`);
+  }
+  return {
+    shutdown: async () => {
+      var _a2, _b2;
+      logger.debug("Shutting down attached LangWatch processors");
+      try {
+        await Promise.all(addedProcessors.map((p) => p.shutdown()));
+      } finally {
+        const candidates = [
+          (_a2 = provider == null ? void 0 : provider._activeSpanProcessor) == null ? void 0 : _a2._spanProcessors,
+          (_b2 = provider == null ? void 0 : provider.activeSpanProcessor) == null ? void 0 : _b2._spanProcessors,
+          provider == null ? void 0 : provider._registeredSpanProcessors
+        ];
+        for (const arr of candidates) {
+          if (!Array.isArray(arr)) continue;
+          for (const p of addedProcessors) {
+            const idx = arr.indexOf(p);
+            if (idx !== -1) arr.splice(idx, 1);
+          }
+        }
+      }
+      logger.info("LangWatch processor shutdown complete");
+    }
+  };
+}
+function createAndStartNodeSdk(options, logger, resource) {
+  var _a, _b, _c, _d, _e;
+  const langwatch = getLangWatchConfig(options);
+  if (langwatch.disabled) {
+    logger.warn("LangWatch integration disabled, using user-provided SpanProcessors and LogRecordProcessors");
+  } else {
+    logger.info(`Using LangWatch ${langwatch.processorType} processors for tracing and logging`);
+  }
+  const spanProcessors = [];
+  const logProcessors = [];
+  if ((_a = options.debug) == null ? void 0 : _a.consoleTracing) {
+    spanProcessors.push(new SimpleSpanProcessor(new ConsoleSpanExporter()));
+    logger.debug("Console tracing enabled; adding console span exporter");
+  }
+  if ((_b = options.debug) == null ? void 0 : _b.consoleLogging) {
+    logProcessors.push(new SimpleLogRecordProcessor(new ConsoleLogRecordExporter()));
+    logger.debug("Console recording of logs enabled; adding console log record processor");
+  }
+  if (!langwatch.disabled) {
+    const traceExporter = new LangWatchTraceExporter({
+      apiKey: langwatch.apiKey,
+      endpoint: langwatch.endpoint
+    });
+    const logExporter = new LangWatchLogsExporter({
+      apiKey: langwatch.apiKey,
+      endpoint: langwatch.endpoint
+    });
+    if (langwatch.processorType === "batch") {
+      spanProcessors.push(new BatchSpanProcessor(traceExporter));
+      logProcessors.push(new BatchLogRecordProcessor(logExporter));
+      logger.debug(`Added LangWatch ${langwatch.processorType} SpanProcessor and LogRecordProcessor to SDK`);
+    } else {
+      spanProcessors.push(new SimpleSpanProcessor(traceExporter));
+      logProcessors.push(new SimpleLogRecordProcessor(logExporter));
+      logger.debug(`Added LangWatch ${langwatch.processorType} SpanProcessor and LogRecordProcessor to SDK`);
+    }
+  }
+  if (options.traceExporter) {
+    spanProcessors.push(new SimpleSpanProcessor(options.traceExporter));
+    logger.debug(`Added user-provided SpanProcessor to SDK`);
+  }
+  if ((_c = options.spanProcessors) == null ? void 0 : _c.length) {
+    spanProcessors.push(...options.spanProcessors);
+    logger.debug(`Added user-provided ${options.spanProcessors.length} SpanProcessors to SDK`);
+  }
+  if ((_d = options.logRecordProcessors) == null ? void 0 : _d.length) {
+    logProcessors.push(...options.logRecordProcessors);
+    logger.debug(`Added user-provided ${options.logRecordProcessors.length} LogRecordProcessors to SDK`);
+  }
+  warnIfMisconfigured(options, langwatch, logger);
+  const loggerProvider = logProcessors.length ? new LoggerProvider({
+    resource,
+    processors: logProcessors
+  }) : void 0;
+  if (loggerProvider) {
+    logger.debug("Created LangWatch logger provider");
+  }
+  const sdk = new NodeSDK({
+    resource,
+    serviceName: options.serviceName,
+    autoDetectResources: options.autoDetectResources,
+    contextManager: options.contextManager,
+    textMapPropagator: options.textMapPropagator,
+    metricReader: options.metricReader,
+    views: options.views,
+    resourceDetectors: options.resourceDetectors,
+    sampler: options.sampler,
+    spanProcessors,
+    logRecordProcessors: logProcessors,
+    spanLimits: options.spanLimits,
+    idGenerator: options.idGenerator,
+    instrumentations: options.instrumentations
+  });
+  sdk.start();
+  logger.info("NodeSDK started successfully");
+  if (process.env.NEXT_RUNTIME === "nodejs") {
+    setImmediate(() => {
+      const globalProvider = trace.getTracerProvider();
+      if (globalProvider.constructor.name === "ProxyTracerProvider") {
+        logger.warn("Global provider is still ProxyTracerProvider after SDK start - applying Next.js 15 workaround");
+        const realProvider = globalProvider._delegate;
+        if ((realProvider == null ? void 0 : realProvider.constructor.name) === "NodeTracerProvider") {
+          trace.setGlobalTracerProvider(realProvider);
+          logger.info("Successfully registered NodeTracerProvider globally for Next.js 15");
+        } else {
+          logger.error("Could not find NodeTracerProvider in proxy delegate - spans may not be exported");
+        }
+      } else {
+        logger.debug(`Provider registered correctly: ${globalProvider.constructor.name}`);
+      }
+    });
+  }
+  if (loggerProvider) {
+    setLangWatchLoggerProvider(loggerProvider);
+    logger.debug("Set LangWatch logger provider");
+  }
+  if (!((_e = options.advanced) == null ? void 0 : _e.disableAutoShutdown)) {
+    let isShuttingDown = false;
+    const gracefulShutdown = async ({ signal, exitAfter }) => {
+      if (isShuttingDown) return;
+      isShuttingDown = true;
+      logger.debug(`${signal}: shutting down OpenTelemetry...`);
+      try {
+        await sdk.shutdown();
+        logger.debug("OpenTelemetry shutdown complete");
+      } catch (err) {
+        logger.error("Error shutting down OpenTelemetry", err);
+      } finally {
+        if (exitAfter) {
+          process.exit(0);
+        }
+      }
+    };
+    process.on("beforeExit", () => {
+      void gracefulShutdown({ signal: "beforeExit", exitAfter: false });
+    });
+    process.on("SIGINT", () => {
+      void gracefulShutdown({ signal: "SIGINT", exitAfter: true });
+    });
+    process.on("SIGTERM", () => {
+      void gracefulShutdown({ signal: "SIGTERM", exitAfter: true });
+    });
+  }
+  return sdk;
+}
+var ensureSetup = () => {
+  const globalProvider = trace.getTracerProvider();
+  const alreadySetup = isConcreteProvider(globalProvider);
+  if (alreadySetup) {
+    return {
+      shutdown: async () => {
+      }
+    };
+  }
+  if (!process.env.LANGWATCH_API_KEY) {
+    return {
+      shutdown: async () => {
+      }
+    };
+  }
+  return setupObservability();
+};
+
+export {
+  setupObservability,
+  ensureSetup
+};
+//# sourceMappingURL=chunk-5NL7Q33G.mjs.map

package/dist/chunk-67A2ZLVV.js

@@ -0,0 +1,36 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _chunkWZTRPR6Ajs = require('./chunk-WZTRPR6A.js');
+
+
+
+
+
+
+
+var _chunkIQ5CSV4Djs = require('./chunk-IQ5CSV4D.js');
+
+
+
+var _chunkBRPEG3YQjs = require('./chunk-BRPEG3YQ.js');
+
+// src/internal/api/client.ts
+var _openapifetch = require('openapi-fetch'); var _openapifetch2 = _interopRequireDefault(_openapifetch);
+var createLangWatchApiClient = (apiKey = ((_a) => (_a = process.env.LANGWATCH_API_KEY) != null ? _a : "")(), endpoint = ((_b) => (_b = process.env.LANGWATCH_ENDPOINT) != null ? _b : (0, _chunkIQ5CSV4Djs.DEFAULT_ENDPOINT))(), projectId = process.env.LANGWATCH_PROJECT_ID) => {
+  return _openapifetch2.default.call(void 0, {
+    baseUrl: endpoint,
+    headers: _chunkBRPEG3YQjs.__spreadProps.call(void 0, _chunkBRPEG3YQjs.__spreadValues.call(void 0, {}, _chunkWZTRPR6Ajs.buildAuthHeaders.call(void 0, { apiKey, projectId })), {
+      "content-type": "application/json",
+      "user-agent": `langwatch-sdk-node/${_chunkIQ5CSV4Djs.version}`,
+      "x-langwatch-sdk-name": _chunkIQ5CSV4Djs.LANGWATCH_SDK_NAME_OBSERVABILITY,
+      "x-langwatch-sdk-language": _chunkIQ5CSV4Djs.LANGWATCH_SDK_LANGUAGE,
+      "x-langwatch-sdk-version": _chunkIQ5CSV4Djs.LANGWATCH_SDK_VERSION,
+      "x-langwatch-sdk-platform": _chunkIQ5CSV4Djs.LANGWATCH_SDK_RUNTIME.call(void 0, )
+    })
+  });
+};
+
+
+
+exports.createLangWatchApiClient = createLangWatchApiClient;
+//# sourceMappingURL=chunk-67A2ZLVV.js.map

package/dist/chunk-67A2ZLVV.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/langwatch/langwatch/typescript-sdk/dist/chunk-67A2ZLVV.js","../src/internal/api/client.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACA;AACA;AACA;AACA;AACA;AACF,sDAA4B;AAC5B;AACE;AACA;AACF,sDAA4B;AAC5B;AACA;AChBA,yGAAgC;AAuBzB,IAAM,yBAAA,EAA2B,CACtC,OAAA,EAAA,CAAiB,CAAA,EAAA,EAAA,GAAA,CAAA,GAAA,EAAA,OAAA,CAAQ,GAAA,CAAI,iBAAA,EAAA,GAAZ,KAAA,EAAA,GAAA,EAAiC,EAAA,CAAA,CAAA,CAAA,EAClD,SAAA,EAAA,CAAmB,CAAA,EAAA,EAAA,GAAA,CAAA,GAAA,EAAA,OAAA,CAAQ,GAAA,CAAI,kBAAA,EAAA,GAAZ,KAAA,EAAA,GAAA,EAAkC,sCAAA,CAAA,CAAA,CAAA,EACrD,UAAA,EAAgC,OAAA,CAAQ,GAAA,CAAI,oBAAA,EAAA,GACzC;AACH,EAAA,OAAO,oCAAA;AAA2B,IAChC,OAAA,EAAS,QAAA;AAAA,IACT,OAAA,EAAS,4CAAA,6CAAA,CAAA,CAAA,EACJ,+CAAA,EAAmB,MAAA,EAAQ,UAAU,CAAC,CAAA,CAAA,EADlC;AAAA,MAEP,cAAA,EAAgB,kBAAA;AAAA,MAChB,YAAA,EAAc,CAAA,mBAAA,EAAsB,wBAAO,CAAA,CAAA;AACnB,MAAA;AACI,MAAA;AACD,MAAA;AACC,MAAA;AAC9B,IAAA;AACD,EAAA;AACH;ADTkD;AACA;AACA;AACA","file":"/home/runner/work/langwatch/langwatch/typescript-sdk/dist/chunk-67A2ZLVV.js","sourcesContent":[null,"import openApiCreateClient from \"openapi-fetch\";\nimport type { paths } from \"../generated/openapi/api-client\";\nimport { version } from \"../../../package.json\";\nimport {\n  LANGWATCH_SDK_LANGUAGE,\n  LANGWATCH_SDK_NAME_OBSERVABILITY,\n  LANGWATCH_SDK_RUNTIME,\n  LANGWATCH_SDK_VERSION,\n} from \"../constants\";\nimport { DEFAULT_ENDPOINT } from \"@/internal/constants\";\nimport { buildAuthHeaders } from \"./auth\";\n\n\n/**\n * Creates a new LangWatch API client.\n * @param apiKey - The API key or Personal Access Token used for authentication.\n *                 Defaults to `LANGWATCH_API_KEY`.\n * @param endpoint - The endpoint to use for the API client. Defaults to `LANGWATCH_ENDPOINT`\n *                   or the internal `DEFAULT_ENDPOINT`.\n * @param projectId - Project identifier. Required when `apiKey` is a PAT\n *                    (`pat-lw-*`). Defaults to `LANGWATCH_PROJECT_ID`.\n * @returns A new LangWatch API client.\n */\nexport const createLangWatchApiClient = (\n  apiKey: string = process.env.LANGWATCH_API_KEY ?? \"\",\n  endpoint: string = process.env.LANGWATCH_ENDPOINT ?? DEFAULT_ENDPOINT,\n  projectId: string | undefined = process.env.LANGWATCH_PROJECT_ID,\n) => {\n  return openApiCreateClient<paths>({\n    baseUrl: endpoint,\n    headers: {\n      ...buildAuthHeaders({ apiKey, projectId }),\n      \"content-type\": \"application/json\",\n      \"user-agent\": `langwatch-sdk-node/${version}`,\n      \"x-langwatch-sdk-name\": LANGWATCH_SDK_NAME_OBSERVABILITY,\n      \"x-langwatch-sdk-language\": LANGWATCH_SDK_LANGUAGE,\n      \"x-langwatch-sdk-version\": LANGWATCH_SDK_VERSION,\n      \"x-langwatch-sdk-platform\": LANGWATCH_SDK_RUNTIME(),\n    },\n  });\n};\n\n\nexport type LangwatchApiClient = ReturnType<typeof createLangWatchApiClient>;\n"]}

package/dist/chunk-6PCLQBJP.js

@@ -0,0 +1,34 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var _chunkQBNX5BQWjs = require('./chunk-QBNX5BQW.js');
+
+// src/cli/utils/apiKey.ts
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+var _dotenv = require('dotenv');
+
+// src/cli/utils/endpoint.ts
+function getEndpoint() {
+  return _chunkQBNX5BQWjs.resolveControlPlaneUrl.call(void 0, );
+}
+
+// src/cli/utils/apiKey.ts
+var checkApiKey = () => {
+  _dotenv.config.call(void 0, { quiet: true });
+  const apiKey = process.env.LANGWATCH_API_KEY;
+  if (!apiKey || apiKey.trim() === "") {
+    const authUrl = `${getEndpoint()}/authorize`;
+    console.error(_chalk2.default.red("Error: LANGWATCH_API_KEY not found."));
+    console.error(_chalk2.default.gray("Get your API key from:"));
+    console.error(_chalk2.default.cyan(`  ${authUrl}`));
+    console.error(_chalk2.default.gray("Then either run:"));
+    console.error(_chalk2.default.cyan("  langwatch login --api-key <your-key>"));
+    console.error(_chalk2.default.gray("Or add it to your .env file:"));
+    console.error(_chalk2.default.cyan("  echo 'LANGWATCH_API_KEY=<your-key>' >> .env"));
+    process.exit(1);
+  }
+};
+
+
+
+exports.checkApiKey = checkApiKey;
+//# sourceMappingURL=chunk-6PCLQBJP.js.map

package/dist/chunk-6PCLQBJP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/langwatch/langwatch/typescript-sdk/dist/chunk-6PCLQBJP.js","../src/cli/utils/apiKey.ts","../src/cli/utils/endpoint.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACJA,4EAAkB;AAClB,gCAAuB;ADMvB;AACA;AEMO,SAAS,WAAA,CAAA,EAAsB;AACpC,EAAA,OAAO,qDAAA,CAAuB;AAChC;AFJA;AACA;ACTO,IAAM,YAAA,EAAc,CAAA,EAAA,GAAY;AAErC,EAAA,4BAAA,EAAS,KAAA,EAAO,KAAK,CAAC,CAAA;AAEtB,EAAA,MAAM,OAAA,EAAS,OAAA,CAAQ,GAAA,CAAI,iBAAA;AAE3B,EAAA,GAAA,CAAI,CAAC,OAAA,GAAU,MAAA,CAAO,IAAA,CAAK,EAAA,IAAM,EAAA,EAAI;AACnC,IAAA,MAAM,QAAA,EAAU,CAAA,EAAA;AACF,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AACA,IAAA;AAChB,EAAA;AACF;ADQqB;AACA;AACA;AACA","file":"/home/runner/work/langwatch/langwatch/typescript-sdk/dist/chunk-6PCLQBJP.js","sourcesContent":[null,"import chalk from \"chalk\";\nimport { config } from \"dotenv\";\nimport { getEndpoint } from \"./endpoint\";\n\nexport const checkApiKey = (): void => {\n  // Load environment variables from .env file\n  config({ quiet: true });\n\n  const apiKey = process.env.LANGWATCH_API_KEY;\n\n  if (!apiKey || apiKey.trim() === \"\") {\n    const authUrl = `${getEndpoint()}/authorize`;\n    console.error(chalk.red(\"Error: LANGWATCH_API_KEY not found.\"));\n    console.error(chalk.gray(\"Get your API key from:\"));\n    console.error(chalk.cyan(`  ${authUrl}`));\n    console.error(chalk.gray(\"Then either run:\"));\n    console.error(chalk.cyan(\"  langwatch login --api-key <your-key>\"));\n    console.error(chalk.gray(\"Or add it to your .env file:\"));\n    console.error(chalk.cyan(\"  echo 'LANGWATCH_API_KEY=<your-key>' >> .env\"));\n    process.exit(1);\n  }\n};","import { resolveControlPlaneUrl } from \"@/cli/utils/governance/resolveEndpoint\";\n\n/**\n * Returns the LangWatch endpoint with any trailing slashes stripped, so callers\n * can safely concatenate paths like `${endpoint}/authorize` without producing\n * `https://app.langwatch.ai//authorize`.\n *\n * Delegates to the single 4-source resolver (flag > env > persisted config >\n * default). This is a thin wrapper preserved for callers that don't need the\n * `--flag` axis. New callers should use `resolveControlPlaneEndpoint()`\n * directly so the source attribution is available.\n *\n * Spec: specs/ai-governance/cli-onboarding/login-unified.feature\n */\nexport function getEndpoint(): string {\n  return resolveControlPlaneUrl();\n}\n"]}