@openmeter/sdk 1.0.0-beta.22 → 1.0.0-beta.221

package/dist/clients/client.d.ts

@@ -1,40 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { IncomingHttpHeaders } from 'http';
-import { Dispatcher } from 'undici';
-import { components } from '../schemas/openapi.js';
-export type OpenMeterConfig = {
-    baseUrl: string;
-    token?: string;
-    username?: string;
-    password?: string;
-    headers?: IncomingHttpHeaders;
-};
-export type RequestOptions = {
-    headers?: IncomingHttpHeaders;
-};
-export type Problem = components['schemas']['Problem'];
-export declare class BaseClient {
-    protected config: OpenMeterConfig;
-    constructor(config: OpenMeterConfig);
-    protected request<T>({ path, method, searchParams, headers, body, options, }: {
-        path: string;
-        method: Dispatcher.HttpMethod;
-        searchParams?: URLSearchParams;
-        headers?: IncomingHttpHeaders;
-        body?: string | Buffer | Uint8Array;
-        options?: RequestOptions;
-    }): Promise<T>;
-    protected getUrl(path: string, searchParams?: URLSearchParams): import("url").URL;
-    protected getAuthHeaders(): IncomingHttpHeaders;
-    protected static toURLSearchParams(params: Record<string, string | number | Date | string[] | undefined>): URLSearchParams;
-}
-export declare class HttpError extends Error {
-    statusCode: number;
-    problem?: Problem;
-    constructor({ statusCode, problem, }: {
-        statusCode: number;
-        problem?: Problem;
-    });
-}

package/dist/clients/client.js

@@ -1,104 +0,0 @@
-import { request } from 'undici';
-export class BaseClient {
-    config;
-    constructor(config) {
-        this.config = config;
-    }
-    async request({ path, method, searchParams, headers, body, options, }) {
-        // Building URL
-        const url = this.getUrl(path, searchParams);
-        // Request options
-        const reqHeaders = {
-            Accept: 'application/json',
-            ...headers,
-            ...this.getAuthHeaders(),
-            ...this.config.headers,
-            ...options?.headers,
-        };
-        const reqOpts = {
-            method,
-            headers: reqHeaders,
-        };
-        // Optional body
-        if (body) {
-            if (!reqHeaders['Content-Type'] && !reqHeaders['content-type']) {
-                throw new Error('Content Type is required with body');
-            }
-            reqOpts.body = body;
-        }
-        const resp = await request(url, reqOpts);
-        // Error handling
-        if (resp.statusCode > 399) {
-            if (resp.headers['content-type'] === 'application/problem+json') {
-                const problem = (await resp.body.json());
-                throw new HttpError({
-                    statusCode: resp.statusCode,
-                    problem,
-                });
-            }
-            // Requests can fail before API, in this case we only have a status code
-            throw new HttpError({
-                statusCode: resp.statusCode,
-            });
-        }
-        // Response parsing
-        if (resp.statusCode === 204 || resp.headers['content-length'] === '0') {
-            return undefined;
-        }
-        if (resp.headers['content-type'] === 'application/json') {
-            return (await resp.body.json());
-        }
-        if (!resp.headers['content-type']) {
-            throw new Error('Missing content type');
-        }
-        throw new Error(`Unknown content type: ${resp.headers['content-type']}`);
-    }
-    getUrl(path, searchParams) {
-        let qs = searchParams ? searchParams.toString() : '';
-        qs = qs.length > 0 ? `?${qs}` : '';
-        const url = new URL(`${path}${qs}`, this.config.baseUrl);
-        return url;
-    }
-    getAuthHeaders() {
-        if (this.config.token) {
-            return {
-                authorization: `Bearer ${this.config.token}`,
-            };
-        }
-        if (this.config.username && this.config.password) {
-            const encoded = Buffer.from(`${this.config.username}:${this.config.password}`).toString('base64');
-            return {
-                authorization: `Basic ${encoded}`,
-            };
-        }
-        return {};
-    }
-    static toURLSearchParams(params) {
-        const searchParams = new URLSearchParams();
-        for (const [key, value] of Object.entries(params)) {
-            if (value === undefined) {
-                continue;
-            }
-            if (Array.isArray(value)) {
-                searchParams.append(key, value.join(','));
-            }
-            else if (value instanceof Date) {
-                searchParams.append(key, value.toISOString());
-            }
-            else {
-                searchParams.append(key, value.toString());
-            }
-        }
-        return searchParams;
-    }
-}
-export class HttpError extends Error {
-    statusCode;
-    problem;
-    constructor({ statusCode, problem, }) {
-        super(problem?.type || 'unexpected status code');
-        this.name = 'HttpError';
-        this.statusCode = statusCode;
-        this.problem = problem;
-    }
-}

package/dist/clients/event.d.ts

@@ -1,79 +0,0 @@
-import { components } from '../schemas/openapi.js';
-import { RequestOptions, BaseClient, OpenMeterConfig } from './client.js';
-type CloudEvents = components['schemas']['Event'];
-export type EventsQueryParams = {
-    /**
-     * @description Limit number of results. Max: 100
-     * @example 25
-     */
-    limit?: number;
-};
-/**
- * Usage Event
- */
-export type Event = {
-    /**
-     * @description The version of the CloudEvents specification which the event uses.
-     * @example 1.0
-     */
-    specversion?: string;
-    /**
-     * @description Unique identifier for the event, defaults to uuid v4.
-     * @example "5c10fade-1c9e-4d6c-8275-c52c36731d3c"
-     */
-    id?: string;
-    /**
-     * Format: uri-reference
-     * @description Identifies the context in which an event happened, defaults to: @openmeter/sdk
-     * @example services/service-0
-     */
-    source?: string;
-    /**
-     * @description Describes the type of event related to the originating occurrence.
-     * @example "api_request"
-     */
-    type: string;
-    /**
-     * @description Describes the subject of the event in the context of the event producer (identified by source).
-     * @example "customer_id"
-     */
-    subject: string;
-    /**
-     * Format: date-time
-     * @description Date of when the occurrence happened.
-     * @example new Date('2023-01-01T01:01:01.001Z')
-     */
-    time?: Date;
-    /**
-     * Format: uri
-     * @description Identifies the schema that data adheres to.
-     */
-    dataschema?: string;
-    /**
-     * @description Content type of the data value. Must adhere to RFC 2046 format.
-     * @example application/json
-     * @enum {string|null}
-     */
-    datacontenttype?: 'application/json';
-    /**
-     * @description The event payload.
-     * @example {
-     *   "duration_ms": "12",
-     *   "path": "/hello"
-     * }
-     */
-    data: Record<string, string | number | Record<string, string | number>>;
-};
-export declare class EventsClient extends BaseClient {
-    constructor(config: OpenMeterConfig);
-    /**
-     * Ingest usage event in a CloudEvents format
-     * @see https://cloudevents.io
-     */
-    ingest(usageEvent: Event, options?: RequestOptions): Promise<void>;
-    /**
-     * List raw events
-     */
-    list(params?: EventsQueryParams, options?: RequestOptions): Promise<CloudEvents[]>;
-}
-export {};

package/dist/clients/event.js

@@ -1,53 +0,0 @@
-import crypto from 'crypto';
-import { BaseClient } from './client.js';
-export class EventsClient extends BaseClient {
-    constructor(config) {
-        super(config);
-    }
-    /**
-     * Ingest usage event in a CloudEvents format
-     * @see https://cloudevents.io
-     */
-    async ingest(usageEvent, options) {
-        if (usageEvent.datacontenttype &&
-            usageEvent.datacontenttype !== 'application/json') {
-            throw new TypeError(`Unsupported datacontenttype: ${usageEvent.datacontenttype}`);
-        }
-        // We default where we can to lower the barrier to use CloudEvents
-        const body = {
-            specversion: usageEvent.specversion ?? '1.0',
-            id: usageEvent.id ?? crypto.randomUUID(),
-            source: usageEvent.source ?? '@openmeter/sdk',
-            type: usageEvent.type,
-            subject: usageEvent.subject,
-            time: usageEvent.time?.toISOString(),
-            datacontenttype: usageEvent.datacontenttype,
-            dataschema: usageEvent.dataschema,
-            data: usageEvent.data,
-        };
-        // Making Request
-        return await this.request({
-            path: '/api/v1/events',
-            method: 'POST',
-            body: JSON.stringify(body),
-            headers: {
-                'Content-Type': 'application/cloudevents+json',
-            },
-            options,
-        });
-    }
-    /**
-     * List raw events
-     */
-    async list(params, options) {
-        const searchParams = params
-            ? BaseClient.toURLSearchParams(params)
-            : undefined;
-        return this.request({
-            method: 'GET',
-            path: `/api/v1/events`,
-            searchParams,
-            options,
-        });
-    }
-}

package/dist/clients/meter.d.ts

@@ -1,71 +0,0 @@
-import { paths, components } from '../schemas/openapi.js';
-import { BaseClient, OpenMeterConfig, RequestOptions } from './client.js';
-export declare enum WindowSize {
-    MINUTE = "MINUTE",
-    HOUR = "HOUR",
-    DAY = "DAY"
-}
-export declare enum MeterAggregation {
-    SUM = "SUM",
-    COUNT = "COUNT",
-    AVG = "AVG",
-    MIN = "MIN",
-    MAX = "MAX"
-}
-export type MeterQueryParams = {
-    /**
-     * @description Subject(s) to filter by.
-     * @example ["customer-1", "customer-2"]
-     */
-    subject?: string[];
-    /**
-     * @description Start date.
-     * Must be aligned with the window size.
-     * Inclusive.
-     */
-    from?: Date;
-    /**
-     * @description End date.
-     * Must be aligned with the window size.
-     * Inclusive.
-     */
-    to?: Date;
-    /**
-     * @description Window Size
-     * If not specified, a single usage aggregate will be returned for the entirety of
-     * the specified period for each subject and group.
-     */
-    windowSize?: WindowSizeType;
-    /**
-     * @description The value is the name of the time zone as defined in the IANA Time Zone Database (http://www.iana.org/time-zones).
-     * If not specified, the UTC timezone will be used.
-     */
-    windowTimeZone?: string;
-    /**
-     * @description Group By
-     * If not specified a single aggregate will be returned for each subject and time window.
-     */
-    groupBy?: string[];
-};
-export type MeterQueryResponse = paths['/api/v1/meters/{meterIdOrSlug}/query']['get']['responses']['200']['content']['application/json'];
-export type Meter = components['schemas']['Meter'];
-export type WindowSizeType = components['schemas']['WindowSize'];
-export declare class MetersClient extends BaseClient {
-    constructor(config: OpenMeterConfig);
-    /**
-     * Get one meter by slug
-     */
-    get(slug: string, options?: RequestOptions): Promise<Meter>;
-    /**
-     * List meters
-     */
-    list(options?: RequestOptions): Promise<Meter[]>;
-    /**
-     * Query a meter
-     */
-    query(slug: string, params?: MeterQueryParams, options?: RequestOptions): Promise<MeterQueryResponse>;
-    /**
-     * List subjects of a meter
-     */
-    subjects(slug: string, options?: RequestOptions): Promise<string[]>;
-}

package/dist/clients/meter.js

@@ -1,64 +0,0 @@
-import { BaseClient } from './client.js';
-export var WindowSize;
-(function (WindowSize) {
-    WindowSize["MINUTE"] = "MINUTE";
-    WindowSize["HOUR"] = "HOUR";
-    WindowSize["DAY"] = "DAY";
-})(WindowSize || (WindowSize = {}));
-export var MeterAggregation;
-(function (MeterAggregation) {
-    MeterAggregation["SUM"] = "SUM";
-    MeterAggregation["COUNT"] = "COUNT";
-    MeterAggregation["AVG"] = "AVG";
-    MeterAggregation["MIN"] = "MIN";
-    MeterAggregation["MAX"] = "MAX";
-})(MeterAggregation || (MeterAggregation = {}));
-export class MetersClient extends BaseClient {
-    constructor(config) {
-        super(config);
-    }
-    /**
-     * Get one meter by slug
-     */
-    async get(slug, options) {
-        return this.request({
-            method: 'GET',
-            path: `/api/v1/meters/${slug}`,
-            options,
-        });
-    }
-    /**
-     * List meters
-     */
-    async list(options) {
-        return this.request({
-            method: 'GET',
-            path: `/api/v1/meters`,
-            options,
-        });
-    }
-    /**
-     * Query a meter
-     */
-    async query(slug, params, options) {
-        const searchParams = params
-            ? BaseClient.toURLSearchParams(params)
-            : undefined;
-        return this.request({
-            method: 'GET',
-            path: `/api/v1/meters/${slug}/query`,
-            searchParams,
-            options,
-        });
-    }
-    /**
-     * List subjects of a meter
-     */
-    async subjects(slug, options) {
-        return this.request({
-            method: 'GET',
-            path: `/api/v1/meters/${slug}/subjects`,
-            options,
-        });
-    }
-}

package/dist/clients/portal.d.ts

@@ -1,23 +0,0 @@
-import { components } from '../schemas/openapi.js';
-import { RequestOptions, BaseClient, OpenMeterConfig } from './client.js';
-export type PortalToken = components['schemas']['PortalToken'];
-export declare class PortalClient extends BaseClient {
-    constructor(config: OpenMeterConfig);
-    /**
-     * Create portal token
-     * Useful for creating a token sharable with your customer to query their own usage
-     * @note OpenMeter Cloud only feature
-     */
-    createToken(token: {
-        subject: string;
-        expiresAt?: Date;
-        allowedMeterSlugs?: string[];
-    }, options?: RequestOptions): Promise<PortalToken>;
-    /**
-     * Invalidate portal token
-     * @note OpenMeter Cloud only feature
-     */
-    invalidateTokens(invalidate?: {
-        subject?: string;
-    }, options?: RequestOptions): Promise<void>;
-}

package/dist/clients/portal.js

@@ -1,37 +0,0 @@
-import { BaseClient } from './client.js';
-export class PortalClient extends BaseClient {
-    constructor(config) {
-        super(config);
-    }
-    /**
-     * Create portal token
-     * Useful for creating a token sharable with your customer to query their own usage
-     * @note OpenMeter Cloud only feature
-     */
-    async createToken(token, options) {
-        return await this.request({
-            path: '/api/v1/portal/tokens',
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(token),
-            options,
-        });
-    }
-    /**
-     * Invalidate portal token
-     * @note OpenMeter Cloud only feature
-     */
-    async invalidateTokens(invalidate = {}, options) {
-        return await this.request({
-            path: '/api/v1/portal/tokens/invalidate',
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify(invalidate),
-            options,
-        });
-    }
-}

package/dist/next.d.ts

@@ -1,15 +0,0 @@
-import type { OpenAIStreamCallbacks } from 'ai';
-import type { TiktokenModel } from 'js-tiktoken';
-type OpenAIUsage = {
-    total_tokens: number;
-    prompt_tokens: number;
-    completion_tokens: number;
-};
-type OpenAIStreamCallbacksWithUsage = OpenAIStreamCallbacks & {
-    onUsage?: (usage: OpenAIUsage) => Promise<void> | void;
-};
-export declare function createOpenAIStreamCallback({ model, prompts, }: {
-    model: TiktokenModel;
-    prompts: string[];
-}, openAIStreamCallbacks: OpenAIStreamCallbacksWithUsage): Promise<OpenAIStreamCallbacks>;
-export {};

package/dist/next.js

@@ -1,46 +0,0 @@
-let encodingForModel;
-export async function createOpenAIStreamCallback({ model, prompts, }, openAIStreamCallbacks) {
-    // Tiktoken is an optional dependency, so we import it conditionally
-    if (!encodingForModel) {
-        const { encodingForModel: encodingForModel_ } = await import('js-tiktoken');
-        encodingForModel = encodingForModel_;
-    }
-    const enc = encodingForModel(model);
-    let promptTokens = 0;
-    let completionTokens = 0;
-    const streamCallbacks = {
-        ...openAIStreamCallbacks,
-        async onStart() {
-            for (const content of prompts) {
-                const tokens = enc.encode(content);
-                promptTokens += tokens.length;
-            }
-            if (typeof openAIStreamCallbacks?.onStart === 'function') {
-                return openAIStreamCallbacks.onStart();
-            }
-        },
-        async onToken(content) {
-            // To test tokenizaton see: https://platform.openai.com/tokenizer
-            const tokens = enc.encode(content);
-            completionTokens += tokens.length;
-            if (typeof openAIStreamCallbacks?.onToken === 'function') {
-                return openAIStreamCallbacks.onToken(content);
-            }
-        },
-        async onFinal(completion) {
-            // Mimicking OpenAI usage metadata API
-            const usage = {
-                total_tokens: promptTokens + completionTokens,
-                prompt_tokens: promptTokens,
-                completion_tokens: completionTokens,
-            };
-            if (typeof openAIStreamCallbacks?.onUsage === 'function') {
-                await openAIStreamCallbacks.onUsage(usage);
-            }
-            if (typeof openAIStreamCallbacks?.onFinal === 'function') {
-                return openAIStreamCallbacks.onFinal(completion);
-            }
-        },
-    };
-    return streamCallbacks;
-}