weflayr 0.23.0 → 0.26.0

package/dist/src/otel/span-processor.js

@@ -0,0 +1,169 @@
+"use strict";
+// Copyright 2024 Langfuse GmbH
+// Licensed under the MIT License.
+// Original source: https://github.com/langfuse/langfuse-js/blob/main/packages/otel/src/span-processor.ts
+//
+// Modifications copyright 2026 Weflayr
+// This file has been modified from its original form:
+//   - Translated from TypeScript to JavaScript
+//   - Removed MediaService integration (no media upload support yet)
+//   - Removed LangfuseAPIClient / app-root marker logic (not used)
+//   - Removed Langfuse-specific span attributes (TRACE_INPUT/OUTPUT/METADATA, IS_APP_ROOT, ENVIRONMENT, RELEASE)
+//   - Mask hook now receives the full flat attribute bag, not a {data} envelope, and runs synchronously
+//   - default_tags are applied as span attributes in onStart
+//   - propagated tags come from Weflayr's tag bag (see propagation.js), not Langfuse's typed schema
+//
+// See LICENSE-MIT in the package root for the full license text.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeflayrSpanProcessor = exports.CONTENT_CAPTURE_ENV = void 0;
+const api_1 = require("@opentelemetry/api");
+const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
+const propagation_1 = require("./propagation");
+const span_filter_1 = require("./span-filter");
+const vercel_ai_sdk_span_filter_1 = require("./vercel-ai-sdk-span-filter");
+const logger_1 = require("../logger");
+// setup({captureMessageContent: ...}) records the choice in this env var (the
+// official OTel GenAI one). Instrumentors gate content on their own knobs
+// (openllmetry reads its own config and captures by default), so the processor
+// enforces the flag itself: when the env var is "false", message content is
+// stripped from every span before export.
+exports.CONTENT_CAPTURE_ENV = 'OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT';
+// The new-semconv JSON message attributes and the legacy indexed
+// `gen_ai.prompt.{i}.*` / `gen_ai.completion.{i}.*` attributes - plus the
+// request's tool definitions and structured-output schema (`ai.schema` is the
+// Vercel AI SDK's spelling): their descriptions are prompt content the same
+// way the messages are.
+const CONTENT_ATTRIBUTES = [
+    'gen_ai.input.messages',
+    'gen_ai.output.messages',
+    'gen_ai.system_instructions',
+    'gen_ai.tool.definitions',
+    'gen_ai.request.structured_output_schema',
+    // The legacy Vercel AI SDK's (ai <= 6) response content. finishReason and
+    // providerMetadata are NOT stripped: metadata and billing, not content.
+    'ai.schema',
+    'ai.response.text',
+    'ai.response.object',
+    'ai.response.reasoning',
+    'ai.response.toolCalls',
+];
+const CONTENT_ATTRIBUTE_PREFIXES = ['gen_ai.prompt.', 'gen_ai.completion.', 'ai.prompt'];
+function _isContentAttribute(key) {
+    return (CONTENT_ATTRIBUTES.includes(key) ||
+        CONTENT_ATTRIBUTE_PREFIXES.some((prefix) => key.startsWith(prefix)));
+}
+// Stamped on every exported span when a `mask` is configured: the mask
+// function's source code, so the stored raw event shows what redaction ran
+// client-side when debugging missing attributes.
+const MASK_FUNCTION_ATTRIBUTE = 'weflayr.mask_function';
+class WeflayrSpanProcessor {
+    _delegate;
+    _defaultTags;
+    _mask;
+    _maskFunctionSource;
+    _shouldExportSpan;
+    _vercelAiSdkSpanFilter;
+    // LLM spans we've started but not yet seen end. On forceFlush we end any
+    // leftovers with ERROR status — covers cases like openllmetry's anthropic
+    // streaming wrapper, which leaks the span when the underlying call
+    // rejects. Generic across providers; no per-provider patching needed.
+    _openLlmSpans;
+    constructor({ exporter, exportMode = 'batch', defaultTags = {}, mask, shouldExportSpan, }) {
+        if (!exporter) {
+            throw new Error('WeflayrSpanProcessor: exporter is required');
+        }
+        this._delegate =
+            exportMode === 'immediate'
+                ? new sdk_trace_base_1.SimpleSpanProcessor(exporter)
+                : new sdk_trace_base_1.BatchSpanProcessor(exporter);
+        this._defaultTags = defaultTags;
+        this._mask = mask;
+        this._maskFunctionSource = mask ? String(mask) : null;
+        this._shouldExportSpan = shouldExportSpan ?? span_filter_1.isDefaultExportSpan;
+        this._vercelAiSdkSpanFilter = new vercel_ai_sdk_span_filter_1.VercelAiSdkSpanFilter();
+        this._openLlmSpans = new Set();
+    }
+    onStart(span, parentContext) {
+        for (const [k, v] of Object.entries(this._defaultTags)) {
+            span.setAttribute(`${propagation_1.EXTRA_TAG_PREFIX}${k}`, v);
+        }
+        const propagated = (0, propagation_1.getMergedMetadataFromContext)(parentContext);
+        for (const [k, v] of Object.entries(propagated)) {
+            span.setAttribute(k, v);
+        }
+        if ((0, span_filter_1.isKnownLLMInstrumentor)(span)) {
+            this._openLlmSpans.add(span);
+        }
+        this._vercelAiSdkSpanFilter.onStart(span);
+        (0, logger_1.debug)('span start: name=%s defaultTags=%d propagatedMetadata=%d', span.name, Object.keys(this._defaultTags).length, Object.keys(propagated).length);
+        return this._delegate.onStart(span, parentContext);
+    }
+    onEnd(span) {
+        // Same concrete object stored in onStart, viewed here as a ReadableSpan.
+        this._openLlmSpans.delete(span);
+        try {
+            const vercelVerdict = this._vercelAiSdkSpanFilter.shouldExport(span);
+            if (vercelVerdict === true) {
+                (0, vercel_ai_sdk_span_filter_1.stampVercelGatewayProviderName)(span);
+            }
+            if (vercelVerdict === false || (vercelVerdict === null && !this._shouldExportSpan(span))) {
+                (0, logger_1.debug)('span end: filtered out name=%s scope=%s', span.name, span.instrumentationScope?.name);
+                return;
+            }
+        }
+        catch {
+            return;
+        }
+        (0, logger_1.debug)('span end: exporting name=%s scope=%s', span.name, span.instrumentationScope?.name);
+        if ((process.env[exports.CONTENT_CAPTURE_ENV] || '').toLowerCase() === 'false') {
+            for (const key of Object.keys(span.attributes)) {
+                if (_isContentAttribute(key))
+                    delete span.attributes[key];
+            }
+        }
+        if (this._mask) {
+            try {
+                const masked = this._mask(span.attributes);
+                if (masked && masked !== span.attributes) {
+                    for (const k of Object.keys(span.attributes))
+                        delete span.attributes[k];
+                    Object.assign(span.attributes, masked);
+                }
+            }
+            catch {
+                for (const k of Object.keys(span.attributes))
+                    delete span.attributes[k];
+            }
+            // Stamped after masking so the mask can't strip it.
+            span.attributes[MASK_FUNCTION_ATTRIBUTE] = this._maskFunctionSource;
+        }
+        return this._delegate.onEnd(span);
+    }
+    async forceFlush() {
+        this._endOrphanedLlmSpans();
+        return this._delegate.forceFlush();
+    }
+    _endOrphanedLlmSpans() {
+        const orphans = [...this._openLlmSpans];
+        this._openLlmSpans.clear();
+        for (const span of orphans) {
+            try {
+                if (typeof span.isRecording === 'function' && !span.isRecording())
+                    continue;
+                span.setStatus({
+                    code: api_1.SpanStatusCode.ERROR,
+                    message: 'weflayr: span did not complete before flush',
+                });
+                span.end();
+                (0, logger_1.debug)('forceFlush: ended orphaned LLM span name=%s', span.name);
+            }
+            catch (err) {
+                (0, logger_1.debug)('forceFlush: failed to end orphan span: %s', err?.message || err);
+            }
+        }
+    }
+    shutdown() {
+        return this._delegate.shutdown();
+    }
+}
+exports.WeflayrSpanProcessor = WeflayrSpanProcessor;

package/dist/src/otel/vercel-ai-sdk-span-filter.d.ts

@@ -0,0 +1,12 @@
+import type { ReadableSpan } from '@opentelemetry/sdk-trace-base';
+export declare class VercelAiSdkSpanFilter {
+    private _openSpanOperations;
+    private _openLegacySchemas;
+    onStart(span: ReadableSpan): void;
+    /**
+     * Export verdict for a Vercel AI SDK span, or null when the span is not
+     * one (the caller falls back to the default filter).
+     */
+    shouldExport(span: ReadableSpan): boolean | null;
+}
+export declare function stampVercelGatewayProviderName(span: ReadableSpan): void;

package/dist/src/otel/vercel-ai-sdk-span-filter.js

@@ -0,0 +1,88 @@
+"use strict";
+// The Vercel AI SDK's OTel integrations emit aggregate spans around each model
+// call, all repeating the same usage counts:
+//   - `@ai-sdk/otel` (ai >= 7, scope "gen_ai"): per-call "chat" spans are
+//     wrapped in "agent_step" + "invoke_agent" spans, and embed/embedMany
+//     emits an outer "embeddings" operation span around the model-call
+//     "embeddings" span(s).
+//   - the legacy integration (ai <= 6, scope "ai"): `ai.<fn>.do<Call>` spans
+//     are wrapped in an outer `ai.<fn>` span.
+// Exactly one span per model call may reach the exporter — exporting an
+// aggregate alongside its children would bill every call twice.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VercelAiSdkSpanFilter = void 0;
+exports.stampVercelGatewayProviderName = stampVercelGatewayProviderName;
+const VERCEL_SEMCONV_SCOPE = 'gen_ai';
+const VERCEL_LEGACY_SCOPE = 'ai';
+const LEGACY_MODEL_CALL_SPAN_NAME = /\.do(Generate|Stream|Embed)$/;
+function _parentSpanId(span) {
+    return span.parentSpanContext?.spanId ?? span.parentSpanId;
+}
+class VercelAiSdkSpanFilter {
+    // spanId -> gen_ai.operation.name for open "gen_ai"-scope spans, so a
+    // span can check what its parent is (children end before their parent).
+    _openSpanOperations = new Map();
+    // spanId -> ai.schema of open legacy generateObject/streamObject ROOT spans:
+    // ai <= 6 records the schema only there, and this filter drops the root, so
+    // the schema is copied onto the model-call child when it starts (the root's
+    // creation attributes are already set by then).
+    _openLegacySchemas = new Map();
+    onStart(span) {
+        const scope = span.instrumentationScope?.name;
+        if (scope === VERCEL_LEGACY_SCOPE) {
+            const schema = span.attributes['ai.schema'];
+            if (schema !== undefined && !LEGACY_MODEL_CALL_SPAN_NAME.test(span.name)) {
+                this._openLegacySchemas.set(span.spanContext().spanId, schema);
+            }
+            const parentSpanId = _parentSpanId(span);
+            if (parentSpanId &&
+                span.attributes['ai.schema'] === undefined &&
+                this._openLegacySchemas.has(parentSpanId)) {
+                span.attributes['ai.schema'] = this._openLegacySchemas.get(parentSpanId);
+            }
+            return;
+        }
+        if (scope !== VERCEL_SEMCONV_SCOPE)
+            return;
+        this._openSpanOperations.set(span.spanContext().spanId, span.attributes['gen_ai.operation.name']);
+    }
+    /**
+     * Export verdict for a Vercel AI SDK span, or null when the span is not
+     * one (the caller falls back to the default filter).
+     */
+    shouldExport(span) {
+        const scope = span.instrumentationScope?.name;
+        if (scope === VERCEL_LEGACY_SCOPE) {
+            this._openLegacySchemas.delete(span.spanContext().spanId);
+            return LEGACY_MODEL_CALL_SPAN_NAME.test(span.name);
+        }
+        if (scope !== VERCEL_SEMCONV_SCOPE) {
+            return null;
+        }
+        const operation = span.attributes['gen_ai.operation.name'];
+        this._openSpanOperations.delete(span.spanContext().spanId);
+        if (operation === 'chat') {
+            return true;
+        }
+        if (operation === 'embeddings') {
+            // Keep the outer aggregate (one event per embed/embedMany call, with the
+            // total usage) and drop the nested model-call span(s) repeating it.
+            const parentSpanId = _parentSpanId(span);
+            return (parentSpanId && this._openSpanOperations.get(parentSpanId)) !== 'embeddings';
+        }
+        // invoke_agent / agent_step (usage aggregates) and execute_tool (no usage).
+        return false;
+    }
+}
+exports.VercelAiSdkSpanFilter = VercelAiSdkSpanFilter;
+// `@ai-sdk/otel` reports the Vercel AI Gateway as the bare provider id
+// "gateway" — too generic a name to special-case downstream. Stamp the weflayr
+// provider override (which the normalizer prefers) with the canonical name.
+// A providerNameOverride set through propagateMetadata was stamped at span start and
+// wins.
+function stampVercelGatewayProviderName(span) {
+    if (span.attributes['gen_ai.provider.name'] === 'gateway' &&
+        span.attributes['weflayr.provider_name'] === undefined) {
+        span.attributes['weflayr.provider_name'] = 'vercel_ai_gateway';
+    }
+}

package/dist/src/setup.d.ts

@@ -0,0 +1,50 @@
+import { type TracerProvider } from '@opentelemetry/api';
+import { WeflayrSpanProcessor, type OtelSpanAttributes, type Tags } from './otel/span-processor';
+export interface SetupOptions {
+    /** Weflayr API key. Defaults to the `WEFLAYR_API_KEY` environment variable. */
+    apiKey?: string;
+    /** Override the intake base URL. Defaults to WEFLAYR_BASE_URL or https://api.weflayr.com. */
+    baseUrl?: string;
+    /** Tags applied to every emitted span. */
+    defaultTags?: Tags;
+    /**
+     * `'batch'` (default) groups spans for throughput. `'immediate'` flushes every
+     * span synchronously — recommended for short-lived runtimes (Lambda, edge).
+     */
+    exportMode?: 'batch' | 'immediate';
+    /**
+     * When `false`, sets OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=false
+     * so instrumentations strip `gen_ai.prompt` / `gen_ai.completion` from spans
+     * before they're emitted. Defaults to `true`.
+     */
+    captureMessageContent?: boolean;
+    /**
+     * Last-line-of-defense scrubber. Receives the span attribute bag just before
+     * export; return the (optionally mutated) bag.
+     */
+    mask?: (attrs: OtelSpanAttributes) => OtelSpanAttributes;
+    /** Whether the exporter logs a warning to stderr on every failed export. Defaults to `true`. */
+    warnOnExportError?: boolean;
+}
+interface State {
+    tracerProvider: TracerProvider | null;
+    processor: WeflayrSpanProcessor | null;
+    beforeExitListener: (() => Promise<void>) | null;
+}
+export declare const _state: State;
+/**
+ * Configure the Weflayr SDK.
+ *
+ * Call once per process, before `autoInstrument`. For per-request or
+ * per-tenant data in a long-running server use `propagateMetadata(...)` —
+ * it stores metadata in OTel's `Context` (built on AsyncLocalStorage) and
+ * isolates correctly across concurrent requests.
+ *
+ * Calling `setup` again is supported but replaces the previous
+ * configuration: the prior processor is shut down and detached so we never
+ * stack exporters (which would otherwise double-export every span and leak
+ * HTTP pools).
+ */
+export declare function setup(options: SetupOptions): void;
+export declare function flush(): Promise<void>;
+export {};

package/dist/src/setup.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._state = void 0;
+exports.setup = setup;
+exports.flush = flush;
+const api_1 = require("@opentelemetry/api");
+const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
+const resources_1 = require("@opentelemetry/resources");
+const exporter_1 = require("./otel/exporter");
+const span_processor_1 = require("./otel/span-processor");
+const logger_1 = require("./logger");
+const package_json_1 = require("../package.json");
+const SDK_LANGUAGE = 'javascript';
+const DEFAULT_BASE_URL = 'https://api.weflayr.com';
+exports._state = {
+    tracerProvider: null,
+    processor: null,
+    beforeExitListener: null,
+};
+// `trace.getTracerProvider()` returns a ProxyTracerProvider that forwards to
+// whoever called `.register()` last. Unwrap it to reach the real provider.
+// The delegate/registration internals aren't part of the public TracerProvider
+// type, so this reaches into them dynamically.
+function _unwrapTracerProvider(p) {
+    const maybeProxy = p;
+    if (maybeProxy && typeof maybeProxy.getDelegate === 'function') {
+        return maybeProxy.getDelegate();
+    }
+    return p;
+}
+// `NodeTracerProvider` 2.x dropped the public `addSpanProcessor` API —
+// processors are construction-time only. To attach to a provider somebody
+// else owns, we splice into the internal MultiSpanProcessor. This matches
+// the actual public OTel JS guidance for composing post-construction.
+function _attachProcessorToExistingProvider(provider, processor) {
+    if (!provider)
+        return false;
+    const internals = provider;
+    if (typeof internals.addSpanProcessor === 'function') {
+        internals.addSpanProcessor(processor);
+        return true;
+    }
+    const multi = internals._activeSpanProcessor;
+    if (multi && Array.isArray(multi._spanProcessors)) {
+        multi._spanProcessors.push(processor);
+        return true;
+    }
+    return false;
+}
+/**
+ * Configure the Weflayr SDK.
+ *
+ * Call once per process, before `autoInstrument`. For per-request or
+ * per-tenant data in a long-running server use `propagateMetadata(...)` —
+ * it stores metadata in OTel's `Context` (built on AsyncLocalStorage) and
+ * isolates correctly across concurrent requests.
+ *
+ * Calling `setup` again is supported but replaces the previous
+ * configuration: the prior processor is shut down and detached so we never
+ * stack exporters (which would otherwise double-export every span and leak
+ * HTTP pools).
+ */
+function setup(options) {
+    const opts = options || {};
+    const apiKey = opts.apiKey || process.env.WEFLAYR_API_KEY;
+    if (typeof apiKey !== 'string' || !apiKey) {
+        throw new Error('weflayr.setup: `apiKey` is required (pass it explicitly or set WEFLAYR_API_KEY)');
+    }
+    const resolvedOptions = { ...opts, apiKey };
+    if (resolvedOptions.captureMessageContent === false) {
+        process.env[span_processor_1.CONTENT_CAPTURE_ENV] = 'false';
+    }
+    else if (resolvedOptions.captureMessageContent === true) {
+        process.env[span_processor_1.CONTENT_CAPTURE_ENV] = 'true';
+    }
+    _detachPreviousWeflayrProcessor();
+    const baseUrl = resolvedOptions.baseUrl || process.env.WEFLAYR_BASE_URL || DEFAULT_BASE_URL;
+    const exporter = (0, exporter_1.buildExporter)({
+        baseUrl,
+        apiKey: resolvedOptions.apiKey,
+        warnOnExportError: resolvedOptions.warnOnExportError !== false,
+    });
+    const processor = new span_processor_1.WeflayrSpanProcessor({
+        exporter,
+        exportMode: resolvedOptions.exportMode || 'batch',
+        defaultTags: resolvedOptions.defaultTags || {},
+        mask: resolvedOptions.mask,
+    });
+    // Adopt an existing TracerProvider when there is one — e.g. the user already
+    // configured Datadog/Honeycomb/OTel, or called weflayr.setup() before.
+    // provider.register() silently refuses to override the proxy if another
+    // provider is already wired in, so naively creating a new provider would
+    // leave our processor attached to a dead one and we'd drop every LLM span.
+    const currentTracerProvider = _unwrapTracerProvider(api_1.trace.getTracerProvider());
+    let tracerProvider;
+    if (_attachProcessorToExistingProvider(currentTracerProvider, processor)) {
+        tracerProvider = currentTracerProvider;
+    }
+    else {
+        const nodeTracerProvider = new sdk_trace_node_1.NodeTracerProvider({
+            resource: (0, resources_1.resourceFromAttributes)({
+                sdk_version: package_json_1.version,
+                sdk_language: SDK_LANGUAGE,
+            }),
+            spanProcessors: [processor],
+        });
+        nodeTracerProvider.register();
+        tracerProvider = nodeTracerProvider;
+    }
+    // beforeExit fires when the event loop empties on a clean exit, giving us a
+    // last async tick to drain buffered spans. It does NOT fire on process.exit()
+    // or uncaught fatals — callers handling those paths still need to call flush
+    // explicitly (e.g. in a finally) for the OTLP HTTP request to complete.
+    if (!exports._state.beforeExitListener) {
+        exports._state.beforeExitListener = async () => {
+            try {
+                await flush();
+            }
+            catch {
+                // best-effort: process is already winding down.
+            }
+        };
+        process.on('beforeExit', exports._state.beforeExitListener);
+    }
+    exports._state.tracerProvider = tracerProvider;
+    exports._state.processor = processor;
+    (0, logger_1.debug)('setup ready: baseUrl=%s exportMode=%s defaultTags=%d', baseUrl, resolvedOptions.exportMode || 'batch', Object.keys(resolvedOptions.defaultTags || {}).length);
+}
+async function flush() {
+    if (!exports._state.processor)
+        return;
+    (0, logger_1.debug)('flush: forcing exporter flush');
+    await exports._state.processor.forceFlush();
+}
+// Shut down + detach the prior weflayr processor — idempotency for setup().
+// Without this, calling setup() twice (key rotation, hot reload, tests that
+// reconfigure) would leave the first processor wired in alongside the new
+// one, double-exporting every span and leaking exporter HTTP pools.
+function _detachPreviousWeflayrProcessor() {
+    const previousProcessor = exports._state.processor;
+    if (!previousProcessor)
+        return;
+    const tp = exports._state.tracerProvider;
+    const multi = tp && tp._activeSpanProcessor;
+    if (multi && Array.isArray(multi._spanProcessors)) {
+        multi._spanProcessors = multi._spanProcessors.filter((processor) => processor !== previousProcessor);
+    }
+    try {
+        previousProcessor.shutdown();
+    }
+    catch {
+        // best-effort cleanup.
+    }
+    exports._state.processor = null;
+}

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "weflayr",
-  "version": "0.23.0",
-  "description": "Weflayr Node.js SDK — instrument any LLM client via JS Proxy",
-  "main": "src/index.js",
-  "types": "index.d.ts",
+  "version": "0.26.0",
+  "description": "Weflayr JS/TS SDK — instrument any LLM client",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "files": [
+    "dist/src"
+  ],
   "scripts": {
     "build": "tsc",
     "generate-api": "openapi-ts && node scripts/generate_facade.mjs",
@@ -36,9 +39,12 @@
   },
   "devDependencies": {
     "@hey-api/openapi-ts": "^0.99.0",
+    "@opentelemetry/context-async-hooks": "^2.8.0",
+    "@types/async-retry": "^1.4.9",
     "@types/node": "^26.1.1",
     "eslint": "^9.18.0",
     "prettier": "^3.4.2",
-    "typescript": "^6.0.3"
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.65.0"
   }
 }

package/.prettierignore

@@ -1,2 +0,0 @@
-src/api/generated/
-dist/

package/.prettierrc.json

@@ -1,7 +0,0 @@
-{
-  "semi": true,
-  "singleQuote": true,
-  "trailingComma": "es5",
-  "printWidth": 100,
-  "tabWidth": 2
-}

package/LICENSE-MIT

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Langfuse GmbH
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/NOTICE

@@ -1,12 +0,0 @@
-Weflayr Node.js SDK
-Copyright 2026 Weflayr
-
-This product includes software derived from langfuse-js
-(https://github.com/langfuse/langfuse-js), Copyright 2024 Langfuse GmbH,
-licensed under the MIT License.
-
-Specifically, the OpenTelemetry span filter, span processor, and tag-propagation
-helpers in src/otel/ are derived from langfuse-js packages/otel and packages/core
-and have been adapted for the Weflayr intake API and tag schema.
-
-See LICENSE-MIT for the full MIT license text.

package/dist/api/generated/index.d.ts

@@ -1,2 +0,0 @@
-export { deleteCustomersTags, deleteKeyMetrics, deleteRevenue, getCustomersTags, getKeyMetrics, getMargin, getRevenue, type Options, setCustomersTags, setKeyMetrics, setRevenue } from './sdk.gen.js';
-export type { AllCustomerTagsOutput, ApiErrorOutput, ClientOptions, CustomerMarginRow, CustomersUpdatedOutput, CustomerTags, CustomerTagsOutput, DeleteCustomersTagsData, DeleteCustomersTagsError, DeleteCustomersTagsErrors, DeleteCustomersTagsResponse, DeleteCustomersTagsResponses, DeleteKeyMetricsData, DeleteKeyMetricsError, DeleteKeyMetricsErrors, DeleteKeyMetricsResponse, DeleteKeyMetricsResponses, DeleteRevenueData, DeleteRevenueError, DeleteRevenueErrors, DeleteRevenueResponse, DeleteRevenueResponses, GetCustomersTagsData, GetCustomersTagsError, GetCustomersTagsErrors, GetCustomersTagsResponse, GetCustomersTagsResponses, GetKeyMetricsData, GetKeyMetricsError, GetKeyMetricsErrors, GetKeyMetricsResponse, GetKeyMetricsResponses, GetMarginData, GetMarginError, GetMarginErrors, GetMarginResponse, GetMarginResponses, GetRevenueData, GetRevenueError, GetRevenueErrors, GetRevenueResponse, GetRevenueResponses, InvalidFieldDetail, InvalidPayloadOutput, KeyMetricOutput, KeyMetricRow, KeyMetricRowOutput, MarginListOutput, RevenueOrKeyMetricDeletedRowOutput, RevenueOrKeyMetricImportedRowOutput, RevenueOutput, RevenueRow, RevenueRowOutput, SetCustomersTagsData, SetCustomersTagsError, SetCustomersTagsErrors, SetCustomersTagsResponse, SetCustomersTagsResponses, SetCustomerTagsInput, SetKeyMetricsData, SetKeyMetricsError, SetKeyMetricsErrors, SetKeyMetricsInput, SetKeyMetricsResponse, SetKeyMetricsResponses, SetRevenueData, SetRevenueError, SetRevenueErrors, SetRevenueInput, SetRevenueResponse, SetRevenueResponses, TagsDeletedOutput } from './types.gen.js';