weflayr 0.23.0 → 0.26.0

package/eslint.config.mjs

@@ -1,36 +0,0 @@
-export default [
-  {
-    languageOptions: {
-      ecmaVersion: 2023,
-      sourceType: "commonjs",
-      globals: {
-        // Node.js
-        require: "readonly",
-        module: "readonly",
-        exports: "writable",
-        __dirname: "readonly",
-        __filename: "readonly",
-        process: "readonly",
-        Buffer: "readonly",
-        console: "readonly",
-        setTimeout: "readonly",
-        clearTimeout: "readonly",
-        setInterval: "readonly",
-        clearInterval: "readonly",
-        // Web platform (available in modern Node)
-        fetch: "readonly",
-        URL: "readonly",
-        ReadableStream: "readonly",
-        TransformStream: "readonly",
-        TextEncoder: "readonly",
-        TextDecoder: "readonly",
-      },
-    },
-    rules: {
-      "no-unused-vars": ["warn", { argsIgnorePattern: "^_" }],
-      "no-undef": "error",
-      "prefer-const": "warn",
-      eqeqeq: ["error", "smart"],
-    },
-  },
-];

package/index.d.ts

@@ -1,167 +0,0 @@
-/** Arbitrary key-value tags applied to OTel spans. */
-export type Tags = Record<string, string | number | boolean>;
-
-/**
- * Span attributes the mask callback can read or scrub. The OpenTelemetry GenAI
- * semantic-convention keys get autocomplete; the index signature catches user
- * tags and provider-specific attributes (e.g. Vercel AI's `ai.*`).
- */
-export interface OtelSpanAttributes {
-  'gen_ai.system'?: string;
-  'gen_ai.operation.name'?: string;
-  'gen_ai.request.model'?: string;
-  'gen_ai.request.temperature'?: number;
-  'gen_ai.request.max_tokens'?: number;
-  'gen_ai.response.model'?: string;
-  'gen_ai.response.id'?: string;
-  'gen_ai.response.finish_reasons'?: string[];
-  'gen_ai.usage.input_tokens'?: number;
-  'gen_ai.usage.output_tokens'?: number;
-  /** Only populated when `captureMessageContent=true`. */
-  'gen_ai.prompt'?: string;
-  /** Only populated when `captureMessageContent=true`. */
-  'gen_ai.completion'?: string;
-  'gen_ai.tool.name'?: string;
-  'gen_ai.tool.call.id'?: string;
-  'gen_ai.tool.call.arguments'?: string;
-  'error.type'?: string;
-  [key: string]: unknown;
-}
-
-/** LLM provider SDKs the `autoInstrument` registry knows how to wire up. */
-export const AiSdk: {
-  readonly OPENAI: 'openai';
-  readonly ANTHROPIC: 'anthropic';
-  readonly BEDROCK: 'bedrock';
-  readonly COHERE: 'cohere';
-  readonly GOOGLE_GENAI: 'google-genai';
-  readonly ELEVENLABS: 'elevenlabs';
-  readonly VERCEL_AI_GATEWAY: 'vercel_ai_gateway';
-};
-export type AiSdk = (typeof AiSdk)[keyof typeof AiSdk];
-
-/**
- * Allowed values for `propagateMetadata({ providerName })`: the actual AI
- * providers a call can be attributed to. Unlike AiSdk this names providers,
- * not SDKs — google-genai is an SDK whose calls are labelled gemini or vertex,
- * and mistral is reached via the OpenAI SDK on the wire but reported as itself.
- */
-export const AIProviderName: {
-  readonly OPENAI: 'openai';
-  readonly ANTHROPIC: 'anthropic';
-  readonly BEDROCK: 'bedrock';
-  readonly COHERE: 'cohere';
-  readonly ELEVENLABS: 'elevenlabs';
-  readonly MISTRAL: 'mistral';
-  readonly VERCEL_AI_GATEWAY: 'vercel_ai_gateway';
-  readonly GEMINI: 'gemini';
-  readonly VERTEX: 'vertex';
-};
-export type AIProviderName = (typeof AIProviderName)[keyof typeof AIProviderName];
-
-export interface SetupOptions {
-  /** Weflayr API key. The server resolves your project_uuid from this token. */
-  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;
-}
-
-/** Initializes the OpenTelemetry tracer + exporter. Call once at app start. */
-export function setup(options: SetupOptions): void;
-
-/**
- * Loads and registers OpenTelemetry instrumentation packages for the given provider SDKs.
- * Throws a clear "install package X" error if the matching package isn't installed.
- *
- * @example
- * await weflayr.autoInstrument({ aiSdks: weflayr.AiSdk.OPENAI, apiKey: '...' });
- * await weflayr.autoInstrument({ aiSdks: [weflayr.AiSdk.OPENAI, weflayr.AiSdk.ANTHROPIC] });
- */
-export function autoInstrument(
-  options: { aiSdks: AiSdk | AiSdk[] } & Partial<SetupOptions>
-): Promise<void>;
-
-export interface PropagateMetadataOptions {
-  /** Product-side feature triggering the LLM call (e.g. `"onboarding-summary"`). */
-  featureName: string;
-  /** Name of the end-user / tenant customer the call is made for. */
-  customerName?: string;
-  /** @deprecated Use `customerName` instead. */
-  customerId?: string;
-  /**
-   * Override for the provider seen on the wire. Set this only if it differs
-   * from the SDK auto-detected by OpenTelemetry — e.g. calls routed through
-   * `vercel_ai_gateway` that proxies to OpenAI/Anthropic but should be
-   * reported as the gateway.
-   */
-  providerName?: AIProviderName;
-  /**
-   * Arbitrary scalar key/value pairs to attach. Values must be `string`,
-   * `number`, or `boolean` so they survive the ClickHouse `Map(String,
-   * String)` column they land in. Avoid `featureName` / `customerName` keys
-   * here — they have dedicated fields.
-   */
-  extraTags?: Record<string, string | number | boolean>;
-}
-
-/**
- * Attach Weflayr metadata to every LLM span created inside `fn`.
- *
- * Every invocation mints a fresh `uuid` that is stamped on every span inside
- * the scope, so all calls made under one `propagateMetadata` block can be
- * correlated downstream.
- *
- * @example
- * await weflayr.propagateMetadata(
- *   { featureName: 'onboarding', customerName: 'Acme Corp', extraTags: { variant: 'control' } },
- *   async () => { await openai.chat.completions.create({ ... }); },
- * );
- */
-export function propagateMetadata<T>(
-  options: PropagateMetadataOptions,
-  fn: () => Promise<T> | T
-): Promise<T> | T;
-
-/**
- * Decorator form. Apply to a class method to propagate metadata around every call.
- * Each invocation of the wrapped function mints its own `uuid`.
- *
- * @example
- * class ChatService {
- *   @weflayr.propagateMetadata({ featureName: 'chat', customerName: 'Acme Corp' })
- *   async reply(userId: string) { ... }
- * }
- */
-export function propagateMetadata(
-  options: PropagateMetadataOptions
-): <T>(target: T, key?: string, descriptor?: PropertyDescriptor) => T;
-
-/** Flush any pending spans. Await before a short-lived runtime exits. */
-export function flush(): Promise<void>;
-
-/**
- * Endpoint functions for the Weflayr public API (revenue, key metrics, customer
- * tags), generated from the platform's OpenAPI spec.
- */
-export * as api from './dist/api';
-
-/** A client for the public API, authenticated with a project API key. */
-export { client, type ApiClientOptions } from './dist/api';

package/openapi-ts.config.mjs

@@ -1,9 +0,0 @@
-import { defineConfig } from '@hey-api/openapi-ts';
-
-// Regenerated by `make generate-sdk-api-clients`; src/api/generated/ is wiped
-// on every run, the handwritten facade lives in src/api/index.ts.
-export default defineConfig({
-  input: '../observability_dashboard/app_api/openapi.json',
-  output: 'src/api/generated',
-  plugins: ['@hey-api/client-fetch'],
-});

package/scripts/generate_facade.mjs

@@ -1,86 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-// Generates src/api/generated/facade.gen.ts: one camelCase-facing wrapper
-// per public-API endpoint exported from src/api/generated/sdk.gen.ts.
-//
-// Run via `npm run generate-api`, right after `openapi-ts` regenerates
-// src/api/generated/ (which wipes the directory first, so this always
-// starts from a clean slate). Do not edit facade.gen.ts by hand - it is
-// overwritten on every run.
-//
-// @hey-api/openapi-ts names an operation's request/response types after its
-// PascalCase operation name (e.g. operation `getRevenue` gets types
-// `GetRevenueData`, `GetRevenueResponse`, `GetRevenueError`), so the
-// only thing this script needs from the generated source is the list of
-// operation names - the type names, and the per-endpoint camelCase/snake_case
-// conversion, follow mechanically from there.
-
-import { readFileSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const GENERATED_DIR = path.join(
-  path.dirname(fileURLToPath(import.meta.url)),
-  '..',
-  'src',
-  'api',
-  'generated'
-);
-const SDK_PATH = path.join(GENERATED_DIR, 'sdk.gen.ts');
-const TYPES_PATH = path.join(GENERATED_DIR, 'types.gen.ts');
-const OUTPUT_PATH = path.join(GENERATED_DIR, 'facade.gen.ts');
-
-const HEADER = `// Generated by services/sdk_node_js/scripts/generate_facade.mjs from
-// sdk.gen.ts. Do not edit by hand.
-
-import { makeEndpoint } from '../makeEndpoint.js';
-import type { CamelCaseDeep } from '../caseConversion.js';
-import * as generated from './sdk.gen.js';
-import type * as generatedTypes from './types.gen.js';
-`;
-
-function pascalCase(operationName) {
-  return operationName[0].toUpperCase() + operationName.slice(1);
-}
-
-function collectOperationNames(sdkSource) {
-  return [...sdkSource.matchAll(/^export const (\w+) = </gm)].map((match) => match[1]);
-}
-
-function collectExportedTypeNames(typesSource) {
-  return new Set([...typesSource.matchAll(/^export type (\w+)/gm)].map((match) => match[1]));
-}
-
-function main() {
-  const sdkSource = readFileSync(SDK_PATH, 'utf8');
-  const typesSource = readFileSync(TYPES_PATH, 'utf8');
-  const operationNames = collectOperationNames(sdkSource);
-  const exportedTypeNames = collectExportedTypeNames(typesSource);
-
-  const lines = [HEADER];
-  for (const operationName of operationNames) {
-    const pascal = pascalCase(operationName);
-    for (const suffix of ['Data', 'Response', 'Error']) {
-      const typeName = `${pascal}${suffix}`;
-      if (!exportedTypeNames.has(typeName)) {
-        throw new Error(
-          `generate_facade.mjs: expected type '${typeName}' for operation '${operationName}' ` +
-            "not found in types.gen.ts - has @hey-api/openapi-ts's naming convention changed?"
-        );
-      }
-    }
-    lines.push(
-      `export const ${operationName} = makeEndpoint<\n` +
-        `  CamelCaseDeep<Omit<generatedTypes.${pascal}Data, 'url'>>,\n` +
-        `  CamelCaseDeep<generatedTypes.${pascal}Response>,\n` +
-        `  CamelCaseDeep<generatedTypes.${pascal}Error>\n` +
-        `>(generated.${operationName});`
-    );
-  }
-
-  writeFileSync(OUTPUT_PATH, lines.join('\n\n') + '\n');
-  console.log(`Generated ${OUTPUT_PATH} (${operationNames.length} endpoints)`);
-}
-
-main();

package/src/api/caseConversion.ts

@@ -1,58 +0,0 @@
-/**
- * Converts between the wire's snake_case JSON keys (also the Python SDK's
- * native casing) and the camelCase keys this SDK exposes to JS callers.
- *
- * `tags` (see CustomerTags / CustomerTagsOutput) is a free-form map of
- * user-chosen tag names, not a fixed schema - its own field name is renamed
- * like any other, but the keys inside it are left untouched in both
- * directions, otherwise a tag literally named e.g. "utm_source" would be
- * silently mangled into "utmSource" on the way out.
- */
-
-const OPAQUE_KEYS = new Set(['tags']);
-
-export type CamelCase<S extends string> = S extends `${infer Head}_${infer Tail}`
-  ? `${Head}${Capitalize<CamelCase<Tail>>}`
-  : S;
-
-export type CamelCaseDeep<T> = T extends readonly (infer Item)[]
-  ? CamelCaseDeep<Item>[]
-  : T extends object
-    ? { [Key in keyof T as CamelCase<Key & string>]: CamelCaseDeep<T[Key]> }
-    : T;
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-function snakeToCamel(key: string): string {
-  return key.replace(/_[a-z0-9]/g, (match) => match[1].toUpperCase());
-}
-
-function camelToSnake(key: string): string {
-  return key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-}
-
-function convertKeysDeep(value: unknown, convertKey: (key: string) => string): unknown {
-  if (Array.isArray(value)) {
-    return value.map((item) => convertKeysDeep(item, convertKey));
-  }
-  if (!isPlainObject(value)) {
-    return value;
-  }
-  const converted: Record<string, unknown> = {};
-  for (const [key, entryValue] of Object.entries(value)) {
-    converted[convertKey(key)] = OPAQUE_KEYS.has(key)
-      ? entryValue
-      : convertKeysDeep(entryValue, convertKey);
-  }
-  return converted;
-}
-
-export function toCamelCaseDeep<T>(value: T): CamelCaseDeep<T> {
-  return convertKeysDeep(value, snakeToCamel) as CamelCaseDeep<T>;
-}
-
-export function toSnakeCaseDeep(value: unknown): unknown {
-  return convertKeysDeep(value, camelToSnake);
-}

package/src/api/generated/client/client.gen.ts

@@ -1,277 +0,0 @@
-// This file is auto-generated by @hey-api/openapi-ts
-
-import { createSseClient } from '../core/serverSentEvents.gen.js';
-import type { HttpMethod } from '../core/types.gen.js';
-import { getValidRequestBody } from '../core/utils.gen.js';
-import type { Client, Config, RequestOptions, ResolvedRequestOptions } from './types.gen.js';
-import {
-  buildUrl,
-  createConfig,
-  createInterceptors,
-  getParseAs,
-  mergeConfigs,
-  mergeHeaders,
-  setAuthParams,
-} from './utils.gen.js';
-
-type ReqInit = Omit<RequestInit, 'body' | 'headers'> & {
-  body?: any;
-  headers: ReturnType<typeof mergeHeaders>;
-};
-
-export const createClient = (config: Config = {}): Client => {
-  let _config = mergeConfigs(createConfig(), config);
-
-  const getConfig = (): Config => ({ ..._config });
-
-  const setConfig = (config: Config): Config => {
-    _config = mergeConfigs(_config, config);
-    return getConfig();
-  };
-
-  const interceptors = createInterceptors<Request, Response, unknown, ResolvedRequestOptions>();
-
-  const beforeRequest = async <
-    TData = unknown,
-    TResponseStyle extends 'data' | 'fields' = 'fields',
-    ThrowOnError extends boolean = boolean,
-    Url extends string = string,
-  >(
-    options: RequestOptions<TData, TResponseStyle, ThrowOnError, Url>,
-  ) => {
-    const opts = {
-      ..._config,
-      ...options,
-      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
-      headers: mergeHeaders(_config.headers, options.headers),
-      serializedBody: undefined as string | undefined,
-    };
-
-    if (opts.security) {
-      await setAuthParams(opts);
-    }
-
-    if (opts.requestValidator) {
-      await opts.requestValidator(opts);
-    }
-
-    if (opts.body !== undefined && opts.bodySerializer) {
-      opts.serializedBody = opts.bodySerializer(opts.body) as string | undefined;
-    }
-
-    // remove Content-Type header if body is empty to avoid sending invalid requests
-    if (opts.body === undefined || opts.serializedBody === '') {
-      opts.headers.delete('Content-Type');
-    }
-
-    const resolvedOpts = opts as typeof opts &
-      ResolvedRequestOptions<TResponseStyle, ThrowOnError, Url>;
-    const url = buildUrl(resolvedOpts);
-
-    return { opts: resolvedOpts, url };
-  };
-
-  const request: Client['request'] = async (options) => {
-    const throwOnError = options.throwOnError ?? _config.throwOnError;
-    const responseStyle = options.responseStyle ?? _config.responseStyle;
-
-    let request: Request | undefined;
-    let response: Response | undefined;
-
-    try {
-      const { opts, url } = await beforeRequest(options);
-      const requestInit: ReqInit = {
-        redirect: 'follow',
-        ...opts,
-        body: getValidRequestBody(opts),
-      };
-
-      request = new Request(url, requestInit);
-
-      for (const fn of interceptors.request.fns) {
-        if (fn) {
-          request = await fn(request, opts);
-        }
-      }
-
-      // fetch must be assigned here, otherwise it would throw the error:
-      // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
-      const _fetch = opts.fetch!;
-
-      response = await _fetch(request);
-
-      for (const fn of interceptors.response.fns) {
-        if (fn) {
-          response = await fn(response, request, opts);
-        }
-      }
-
-      const result = {
-        request,
-        response,
-      };
-
-      if (response.ok) {
-        const parseAs =
-          (opts.parseAs === 'auto'
-            ? getParseAs(response.headers.get('Content-Type'))
-            : opts.parseAs) ?? 'json';
-
-        if (response.status === 204 || response.headers.get('Content-Length') === '0') {
-          let emptyData: any;
-          switch (parseAs) {
-            case 'arrayBuffer':
-            case 'blob':
-            case 'text':
-              emptyData = await response[parseAs]();
-              break;
-            case 'formData':
-              emptyData = new FormData();
-              break;
-            case 'stream':
-              emptyData = response.body;
-              break;
-            case 'json':
-            default:
-              emptyData = {};
-              break;
-          }
-          return opts.responseStyle === 'data'
-            ? emptyData
-            : {
-                data: emptyData,
-                ...result,
-              };
-        }
-
-        let data: any;
-        switch (parseAs) {
-          case 'arrayBuffer':
-          case 'blob':
-          case 'formData':
-          case 'text':
-            data = await response[parseAs]();
-            break;
-          case 'json': {
-            // Some servers return 200 with no Content-Length and empty body.
-            // response.json() would throw; read as text and parse if non-empty.
-            const text = await response.text();
-            data = text ? JSON.parse(text) : {};
-            break;
-          }
-          case 'stream':
-            return opts.responseStyle === 'data'
-              ? response.body
-              : {
-                  data: response.body,
-                  ...result,
-                };
-        }
-
-        if (parseAs === 'json') {
-          if (opts.responseValidator) {
-            await opts.responseValidator(data);
-          }
-
-          if (opts.responseTransformer) {
-            data = await opts.responseTransformer(data);
-          }
-        }
-
-        return opts.responseStyle === 'data'
-          ? data
-          : {
-              data,
-              ...result,
-            };
-      }
-
-      const textError = await response.text();
-      let jsonError: unknown;
-
-      try {
-        jsonError = JSON.parse(textError);
-      } catch {
-        // noop
-      }
-
-      throw jsonError ?? textError;
-    } catch (error) {
-      let finalError = error;
-
-      for (const fn of interceptors.error.fns) {
-        if (fn) {
-          finalError = await fn(finalError, response, request, options as ResolvedRequestOptions);
-        }
-      }
-
-      finalError = finalError || {};
-
-      if (throwOnError) {
-        throw finalError;
-      }
-
-      // TODO: we probably want to return error and improve types
-      return responseStyle === 'data'
-        ? undefined
-        : {
-            error: finalError,
-            request,
-            response,
-          };
-    }
-  };
-
-  const makeMethodFn = (method: Uppercase<HttpMethod>) => (options: RequestOptions) =>
-    request({ ...options, method });
-
-  const makeSseFn = (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => {
-    const { opts, url } = await beforeRequest(options);
-    return createSseClient({
-      ...opts,
-      body: opts.body as BodyInit | null | undefined,
-      method,
-      onRequest: async (url, init) => {
-        let request = new Request(url, init);
-        for (const fn of interceptors.request.fns) {
-          if (fn) {
-            request = await fn(request, opts);
-          }
-        }
-        return request;
-      },
-      serializedBody: getValidRequestBody(opts) as BodyInit | null | undefined,
-      url,
-    });
-  };
-
-  const _buildUrl: Client['buildUrl'] = (options) => buildUrl({ ..._config, ...options });
-
-  return {
-    buildUrl: _buildUrl,
-    connect: makeMethodFn('CONNECT'),
-    delete: makeMethodFn('DELETE'),
-    get: makeMethodFn('GET'),
-    getConfig,
-    head: makeMethodFn('HEAD'),
-    interceptors,
-    options: makeMethodFn('OPTIONS'),
-    patch: makeMethodFn('PATCH'),
-    post: makeMethodFn('POST'),
-    put: makeMethodFn('PUT'),
-    request,
-    setConfig,
-    sse: {
-      connect: makeSseFn('CONNECT'),
-      delete: makeSseFn('DELETE'),
-      get: makeSseFn('GET'),
-      head: makeSseFn('HEAD'),
-      options: makeSseFn('OPTIONS'),
-      patch: makeSseFn('PATCH'),
-      post: makeSseFn('POST'),
-      put: makeSseFn('PUT'),
-      trace: makeSseFn('TRACE'),
-    },
-    trace: makeMethodFn('TRACE'),
-  } as Client;
-};

package/src/api/generated/client/index.ts

@@ -1,27 +0,0 @@
-// This file is auto-generated by @hey-api/openapi-ts
-
-export type { Auth } from '../core/auth.gen.js';
-export type { QuerySerializerOptions } from '../core/bodySerializer.gen.js';
-export {
-  formDataBodySerializer,
-  jsonBodySerializer,
-  urlSearchParamsBodySerializer,
-} from '../core/bodySerializer.gen.js';
-export { buildClientParams } from '../core/params.gen.js';
-export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen.js';
-export type { ServerSentEventsResult } from '../core/serverSentEvents.gen.js';
-export type { ClientMeta } from '../core/types.gen.js';
-export { createClient } from './client.gen.js';
-export type {
-  Client,
-  ClientOptions,
-  Config,
-  CreateClientConfig,
-  Options,
-  RequestOptions,
-  RequestResult,
-  ResolvedRequestOptions,
-  ResponseStyle,
-  TDataShape,
-} from './types.gen.js';
-export { createConfig, mergeHeaders } from './utils.gen.js';