@redonvn/event-ws-cliproxyapi-sdk 0.1.0

package/dist/shared/errors.d.ts

@@ -0,0 +1,13 @@
+import type { OpenAIErrorResponse, ErrorResponse, StatusResponse, JsonObject } from './types.js';
+export type ManagementErrorResponse = ErrorResponse;
+export type ApiErrorPayload = OpenAIErrorResponse | ManagementErrorResponse | StatusResponse | JsonObject | {
+    error: string;
+};
+export declare class APIError extends Error {
+    readonly status: number;
+    readonly payload?: ApiErrorPayload;
+    constructor(message: string, status: number, payload?: ApiErrorPayload);
+}
+export declare function isOpenAIError(payload: unknown): payload is OpenAIErrorResponse;
+export declare function isStatusError(payload: unknown): payload is StatusResponse;
+export declare function isManagementError(payload: unknown): payload is ManagementErrorResponse;

package/dist/shared/errors.js

@@ -0,0 +1,26 @@
+export class APIError extends Error {
+    constructor(message, status, payload) {
+        super(message);
+        this.name = 'APIError';
+        this.status = status;
+        this.payload = payload;
+    }
+}
+export function isOpenAIError(payload) {
+    if (!payload || typeof payload !== 'object')
+        return false;
+    const obj = payload;
+    return !!obj.error && typeof obj.error.message === 'string' && typeof obj.error.type === 'string';
+}
+export function isStatusError(payload) {
+    if (!payload || typeof payload !== 'object')
+        return false;
+    const obj = payload;
+    return typeof obj.status === 'string' && (obj.status === 'error' || obj.status === 'wait' || obj.status === 'ok');
+}
+export function isManagementError(payload) {
+    if (!payload || typeof payload !== 'object')
+        return false;
+    const obj = payload;
+    return typeof obj.error === 'string';
+}

package/dist/shared/http.d.ts

@@ -0,0 +1,29 @@
+export interface HttpClientOptions {
+    baseUrl: string;
+    accessKey?: string;
+    managementKey?: string;
+    localPassword?: string;
+    fetch?: typeof fetch;
+}
+export interface RequestOptions {
+    query?: Record<string, string | number | boolean | undefined>;
+    headers?: Record<string, string>;
+}
+export declare class BaseHttpClient {
+    readonly baseUrl: string;
+    protected accessKey?: string;
+    protected managementKey?: string;
+    protected localPassword?: string;
+    protected fetchImpl: typeof fetch;
+    constructor(options: HttpClientOptions);
+    setAccessKey(key?: string): void;
+    setManagementKey(key?: string): void;
+    setLocalPassword(value?: string): void;
+    getWebsocketUrl(path?: string): string;
+    protected buildUrl(path: string, query?: Record<string, string | number | boolean | undefined>): string;
+    protected requestJson<T>(method: string, path: string, body?: unknown, options?: RequestOptions, auth?: 'access' | 'management' | 'local'): Promise<T>;
+    protected requestText(method: string, path: string, body?: string, options?: RequestOptions, auth?: 'access' | 'management' | 'local'): Promise<string>;
+    protected requestRaw(method: string, path: string, body?: BodyInit, options?: RequestOptions, auth?: 'access' | 'management' | 'local'): Promise<Response>;
+    protected applyAuth(headers: Record<string, string>, auth?: 'access' | 'management' | 'local'): void;
+    protected throwApiError(res: Response): Promise<never>;
+}

package/dist/shared/http.js

@@ -0,0 +1,125 @@
+import { APIError } from './errors.js';
+export class BaseHttpClient {
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/+$/, '');
+        this.accessKey = options.accessKey;
+        this.managementKey = options.managementKey;
+        this.localPassword = options.localPassword;
+        this.fetchImpl = options.fetch ?? globalThis.fetch;
+        if (!this.fetchImpl) {
+            throw new Error('fetch is not available; pass options.fetch');
+        }
+    }
+    setAccessKey(key) {
+        this.accessKey = key;
+    }
+    setManagementKey(key) {
+        this.managementKey = key;
+    }
+    setLocalPassword(value) {
+        this.localPassword = value;
+    }
+    getWebsocketUrl(path = '/v1/ws') {
+        const base = this.baseUrl.replace(/\/+$/, '');
+        const wsBase = base.replace(/^http/, 'ws');
+        const normalized = path.startsWith('/') ? path : `/${path}`;
+        return `${wsBase}${normalized}`;
+    }
+    buildUrl(path, query) {
+        const url = new URL(path, this.baseUrl);
+        if (query) {
+            for (const [key, value] of Object.entries(query)) {
+                if (value === undefined)
+                    continue;
+                url.searchParams.set(key, String(value));
+            }
+        }
+        return url.toString();
+    }
+    async requestJson(method, path, body, options, auth) {
+        const headers = {
+            'Content-Type': 'application/json',
+            ...(options?.headers ?? {})
+        };
+        this.applyAuth(headers, auth);
+        const res = await this.fetchImpl(this.buildUrl(path, options?.query), {
+            method,
+            headers,
+            body: body === undefined ? undefined : JSON.stringify(body)
+        });
+        if (!res.ok) {
+            await this.throwApiError(res);
+        }
+        const text = await res.text();
+        if (!text)
+            return undefined;
+        return JSON.parse(text);
+    }
+    async requestText(method, path, body, options, auth) {
+        const headers = {
+            ...(options?.headers ?? {})
+        };
+        this.applyAuth(headers, auth);
+        const res = await this.fetchImpl(this.buildUrl(path, options?.query), {
+            method,
+            headers,
+            body
+        });
+        if (!res.ok) {
+            await this.throwApiError(res);
+        }
+        return res.text();
+    }
+    async requestRaw(method, path, body, options, auth) {
+        const headers = {
+            ...(options?.headers ?? {})
+        };
+        this.applyAuth(headers, auth);
+        const res = await this.fetchImpl(this.buildUrl(path, options?.query), {
+            method,
+            headers,
+            body
+        });
+        if (!res.ok) {
+            await this.throwApiError(res);
+        }
+        return res;
+    }
+    applyAuth(headers, auth) {
+        if (auth === 'access' && this.accessKey) {
+            headers.Authorization = `Bearer ${this.accessKey}`;
+        }
+        if (auth === 'management' && this.managementKey) {
+            headers.Authorization = `Bearer ${this.managementKey}`;
+        }
+        if (auth === 'local' && this.localPassword) {
+            headers.Authorization = `Bearer ${this.localPassword}`;
+            headers['X-Local-Password'] = this.localPassword;
+        }
+    }
+    async throwApiError(res) {
+        let payload;
+        let message = `Request failed (${res.status})`;
+        const text = await res.text();
+        if (text) {
+            try {
+                payload = JSON.parse(text);
+            }
+            catch {
+                payload = { error: text };
+            }
+            if (payload && typeof payload === 'object') {
+                const obj = payload;
+                if (typeof obj.error === 'string')
+                    message = obj.error;
+                else if (obj.error && typeof obj.error === 'object' && typeof obj.error.message === 'string') {
+                    message = obj.error.message;
+                }
+                else if (typeof obj.message === 'string') {
+                    message = obj.message;
+                }
+            }
+        }
+        throw new APIError(message, res.status, (payload ?? { error: message }));
+    }
+}

package/dist/shared/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './errors.js';

package/dist/shared/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './errors.js';