weflayr 0.22.0 → 0.22.2

package/dist/api/index.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Entry point for the Weflayr public API (revenue, key metrics, customer tags).
+ *
+ * The endpoint functions and types under ./generated are produced from the
+ * platform's OpenAPI spec (`make generate-sdk-api-clients`) and speak the
+ * wire's snake_case, same as the Python SDK. generated/facade.gen.ts (also
+ * produced by that command, via scripts/generate_facade.mjs) wraps every
+ * endpoint so JS callers use camelCase instead - see ./caseConversion and
+ * ./makeEndpoint. This module is the handwritten front door that configures
+ * their client:
+ *
+ *     const weflayr = require('weflayr');
+ *
+ *     const apiClient = weflayr.client({ apiKey: 'wf-...' });
+ *     const { data } = await weflayr.api.getRevenue({ client: apiClient, throwOnError: true });
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_BASE_URL = void 0;
+exports.client = client;
+const client_1 = require("./generated/client");
+exports.DEFAULT_BASE_URL = 'https://app.weflayr.com/api';
+/** A client for the public API, authenticated with a project API key. */
+function client(options = {}) {
+    const apiKey = options.apiKey || process.env.WEFLAYR_API_KEY;
+    if (!apiKey) {
+        throw new Error('weflayr.client: `apiKey` is required (pass it explicitly or set WEFLAYR_API_KEY)');
+    }
+    return (0, client_1.createClient)((0, client_1.createConfig)({
+        baseUrl: options.baseUrl ?? exports.DEFAULT_BASE_URL,
+        auth: () => apiKey,
+    }));
+}
+__exportStar(require("./generated/facade.gen"), exports);

package/dist/api/makeEndpoint.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Wraps a generated public-API endpoint function so its `body`/`path`/`query`
+ * are converted from camelCase to the wire's snake_case on the way out, and
+ * its `data`/`error` are converted back to camelCase on the way in.
+ *
+ * Instantiated once per endpoint in generated/facade.gen.ts, produced by
+ * scripts/generate_facade.mjs - see that script for how the per-endpoint
+ * type arguments are derived.
+ */
+import type { Client } from './generated/client';
+export interface ClientOption {
+    client: Client;
+    throwOnError?: boolean;
+    headers?: HeadersInit;
+}
+export interface CallResult<TData, TError> {
+    data?: TData;
+    error?: TError;
+    request?: Request;
+    response?: Response;
+}
+type WireResult = {
+    data?: unknown;
+    error?: unknown;
+};
+export declare function makeEndpoint<TParams extends object, TData, TError>(wireFn: (options: any) => Promise<WireResult>): (options: ClientOption & TParams) => Promise<CallResult<TData, TError>>;
+export {};

package/dist/api/makeEndpoint.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Wraps a generated public-API endpoint function so its `body`/`path`/`query`
+ * are converted from camelCase to the wire's snake_case on the way out, and
+ * its `data`/`error` are converted back to camelCase on the way in.
+ *
+ * Instantiated once per endpoint in generated/facade.gen.ts, produced by
+ * scripts/generate_facade.mjs - see that script for how the per-endpoint
+ * type arguments are derived.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEndpoint = makeEndpoint;
+const caseConversion_1 = require("./caseConversion");
+function makeEndpoint(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+wireFn) {
+    return async (options) => {
+        const wireOptions = { ...options };
+        for (const key of ['body', 'path', 'query']) {
+            if (wireOptions[key] !== undefined) {
+                wireOptions[key] = (0, caseConversion_1.toSnakeCaseDeep)(wireOptions[key]);
+            }
+        }
+        let result;
+        try {
+            result = await wireFn(wireOptions);
+        }
+        catch (error) {
+            throw (0, caseConversion_1.toCamelCaseDeep)(error);
+        }
+        return {
+            ...result,
+            data: result.data !== undefined ? (0, caseConversion_1.toCamelCaseDeep)(result.data) : undefined,
+            error: result.error !== undefined ? (0, caseConversion_1.toCamelCaseDeep)(result.error) : undefined,
+        };
+    };
+}

package/index.d.ts

@@ -33,31 +33,29 @@ export const AiSdk: {
   readonly OPENAI: 'openai';
   readonly ANTHROPIC: 'anthropic';
   readonly BEDROCK: 'bedrock';
-  readonly AZURE: 'azure';
   readonly COHERE: 'cohere';
-  readonly TOGETHER: 'together';
-  readonly GOOGLE_VERTEX: 'google-vertex';
   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 })`: every SDK the
- * auto-instrumentation registry knows, plus providers reached via the OpenAI
- * SDK on the wire but reported as themselves (e.g. Vercel AI Gateway).
+ * 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 AZURE: 'azure';
   readonly COHERE: 'cohere';
-  readonly TOGETHER: 'together';
-  readonly GOOGLE_VERTEX: 'google-vertex';
-  readonly GOOGLE_GENAI: 'google-genai';
   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];
 
@@ -104,8 +102,10 @@ export function autoInstrument(
 export interface PropagateMetadataOptions {
   /** Product-side feature triggering the LLM call (e.g. `"onboarding-summary"`). */
   featureName: string;
-  /** Identifier of the end-user / tenant the call is made for. */
-  customerId: 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
@@ -116,7 +116,7 @@ export interface PropagateMetadataOptions {
   /**
    * 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` / `customerId` keys
+   * String)` column they land in. Avoid `featureName` / `customerName` keys
    * here — they have dedicated fields.
    */
   extraTags?: Record<string, string | number | boolean>;
@@ -131,7 +131,7 @@ export interface PropagateMetadataOptions {
  *
  * @example
  * await weflayr.propagateMetadata(
- *   { featureName: 'onboarding', customerId: '#3756', extraTags: { variant: 'control' } },
+ *   { featureName: 'onboarding', customerName: 'Acme Corp', extraTags: { variant: 'control' } },
  *   async () => { await openai.chat.completions.create({ ... }); },
  * );
  */
@@ -146,7 +146,7 @@ export function propagateMetadata<T>(
  *
  * @example
  * class ChatService {
- *   @weflayr.propagateMetadata({ featureName: 'chat', customerId: 'user_42' })
+ *   @weflayr.propagateMetadata({ featureName: 'chat', customerName: 'Acme Corp' })
  *   async reply(userId: string) { ... }
  * }
  */
@@ -156,3 +156,12 @@ export function propagateMetadata(
 
 /** 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

@@ -0,0 +1,9 @@
+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/package.json

@@ -1,10 +1,14 @@
 {
   "name": "weflayr",
-  "version": "0.22.0",
+  "version": "0.22.2",
   "description": "Weflayr Node.js SDK — instrument any LLM client via JS Proxy",
   "main": "src/index.js",
   "types": "index.d.ts",
   "scripts": {
+    "build": "tsc",
+    "generate-api": "openapi-ts && node scripts/generate_facade.mjs",
+    "pretest": "npm run build",
+    "prepublishOnly": "npm run build",
     "test": "node --test",
     "lint": "eslint src tests",
     "lint:fix": "eslint src tests --fix",
@@ -31,7 +35,10 @@
     "async-retry": "^1.3.3"
   },
   "devDependencies": {
+    "@hey-api/openapi-ts": "^0.99.0",
+    "@types/node": "^26.1.1",
     "eslint": "^9.18.0",
-    "prettier": "^3.4.2"
+    "prettier": "^3.4.2",
+    "typescript": "^6.0.3"
   }
 }

package/scripts/generate_facade.mjs

@@ -0,0 +1,86 @@
+#!/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

@@ -0,0 +1,58 @@
+/**
+ * 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

@@ -0,0 +1,277 @@
+// 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;
+};