geniebox-shared-lib 2.1.1 → 2.1.3

package/dist/endpoint.client.d.ts

@@ -0,0 +1,12 @@
+import { OnModuleInit } from "@nestjs/common";
+import { ClientGrpc } from "@nestjs/microservices";
+import { EndpointServiceClient } from "./endpoint.interface";
+export declare class EndpointClient implements OnModuleInit {
+    private readonly client;
+    private readonly logger;
+    private endpointClient?;
+    constructor(client: ClientGrpc);
+    onModuleInit(): void;
+    get service(): EndpointServiceClient;
+    isReady(): boolean;
+}

package/dist/endpoint.client.js

@@ -0,0 +1,43 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var EndpointClient_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndpointClient = void 0;
+const common_1 = require("@nestjs/common");
+let EndpointClient = EndpointClient_1 = class EndpointClient {
+    constructor(client) {
+        this.client = client;
+        this.logger = new common_1.Logger(EndpointClient_1.name);
+    }
+    onModuleInit() {
+        this.endpointClient =
+            this.client.getService("EndpointService");
+        this.logger.log("EndpointServiceClient initialized");
+    }
+    get service() {
+        if (!this.endpointClient) {
+            throw new common_1.InternalServerErrorException("EndpointService is not initialized yet");
+        }
+        return this.endpointClient;
+    }
+    isReady() {
+        return !!this.endpointClient;
+    }
+};
+exports.EndpointClient = EndpointClient;
+exports.EndpointClient = EndpointClient = EndpointClient_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)("ENDPOINT_PACKAGE")),
+    __metadata("design:paramtypes", [Object])
+], EndpointClient);

package/dist/endpoint.interface.d.ts

@@ -0,0 +1,338 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import type { handleUnaryCall, Metadata, UntypedServiceImplementation } from "@grpc/grpc-js";
+import { Observable } from "rxjs";
+export declare const protobufPackage = "endpoint";
+export interface Provider {
+    id: string;
+    name: string;
+    displayName: string;
+    description: string;
+    baseUrl: string;
+    isActive: boolean;
+    /** JSON string */
+    metadata: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface Model {
+    id: string;
+    providerId: string;
+    providerName: string;
+    name: string;
+    displayName: string;
+    description: string;
+    contextWindow: number;
+    maxTokens: number;
+    supportStreaming: boolean;
+    isActive: boolean;
+    /** JSON string */
+    metadata: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface Pricing {
+    id: string;
+    modelId: string;
+    modelName: string;
+    /** price per 1000 input tokens */
+    inputTokenPrice: number;
+    /** price per 1000 output tokens */
+    outputTokenPrice: number;
+    currency: string;
+    effectiveFrom: string;
+    effectiveTo: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface EndpointConfig {
+    id: string;
+    path: string;
+    providerId: string;
+    providerName: string;
+    queueName: string;
+    methods: string[];
+    description: string;
+    isActive: boolean;
+    /** JSON string */
+    metadata: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface EndpointRequest {
+    /** e.g.: /openai/create */
+    path: string;
+}
+export interface ProvidersRequest {
+    /** only active providers */
+    activeOnly: boolean;
+}
+export interface ModelsRequest {
+    /** filter by provider */
+    providerId: string;
+    /** only active models */
+    activeOnly: boolean;
+}
+export interface PricingRequest {
+    /** filter by model */
+    modelId: string;
+    /** currency (USD, EUR, etc.) */
+    currency: string;
+}
+export interface ValidateEndpointRequest {
+    path: string;
+    /** GET, POST, etc. */
+    method: string;
+}
+export interface CreateEndpointRequest {
+    /** required, must be unique */
+    path: string;
+    /** required */
+    providerId: string;
+    /** required */
+    queueName: string;
+    /** required, e.g. ["POST"] */
+    methods: string[];
+    /** optional */
+    description: string;
+    /** optional, defaults to true */
+    isActive: boolean;
+    /** optional, JSON string */
+    metadata: string;
+}
+export interface UpdateEndpointRequest {
+    /** required */
+    id: string;
+    /** optional */
+    path: string;
+    /** optional */
+    providerId: string;
+    /** optional */
+    queueName: string;
+    /** optional */
+    methods: string[];
+    /** optional */
+    description: string;
+    /** optional */
+    isActive: boolean;
+    /** optional, JSON string */
+    metadata: string;
+}
+export interface GetEndpointByIdRequest {
+    /** required */
+    id: string;
+}
+export interface ListEndpointsRequest {
+    /** optional, filter by isActive */
+    activeOnly: boolean;
+    /** optional, filter by provider */
+    providerId: string;
+}
+export interface DeleteEndpointRequest {
+    /** required */
+    id: string;
+    /** optional, if true performs hard delete, otherwise soft delete (isActive=false) */
+    hardDelete: boolean;
+}
+export interface ProvidersResponse {
+    providers: Provider[];
+}
+export interface ModelsResponse {
+    models: Model[];
+}
+export interface PricingResponse {
+    pricing: Pricing[];
+}
+export interface ValidateEndpointResponse {
+    isValid: boolean;
+    error: string;
+    config?: EndpointConfig | undefined;
+}
+export interface CreateEndpointResponse {
+    endpoint?: EndpointConfig | undefined;
+    success: boolean;
+    error: string;
+}
+export interface UpdateEndpointResponse {
+    endpoint?: EndpointConfig | undefined;
+    success: boolean;
+    error: string;
+}
+export interface GetEndpointByIdResponse {
+    endpoint?: EndpointConfig | undefined;
+    found: boolean;
+}
+export interface ListEndpointsResponse {
+    endpoints: EndpointConfig[];
+    total: number;
+}
+export interface DeleteEndpointResponse {
+    success: boolean;
+    error: string;
+}
+export declare const ENDPOINT_PACKAGE_NAME = "endpoint";
+export declare const Provider: MessageFns<Provider>;
+export declare const Model: MessageFns<Model>;
+export declare const Pricing: MessageFns<Pricing>;
+export declare const EndpointConfig: MessageFns<EndpointConfig>;
+export declare const EndpointRequest: MessageFns<EndpointRequest>;
+export declare const ProvidersRequest: MessageFns<ProvidersRequest>;
+export declare const ModelsRequest: MessageFns<ModelsRequest>;
+export declare const PricingRequest: MessageFns<PricingRequest>;
+export declare const ValidateEndpointRequest: MessageFns<ValidateEndpointRequest>;
+export declare const CreateEndpointRequest: MessageFns<CreateEndpointRequest>;
+export declare const UpdateEndpointRequest: MessageFns<UpdateEndpointRequest>;
+export declare const GetEndpointByIdRequest: MessageFns<GetEndpointByIdRequest>;
+export declare const ListEndpointsRequest: MessageFns<ListEndpointsRequest>;
+export declare const DeleteEndpointRequest: MessageFns<DeleteEndpointRequest>;
+export declare const ProvidersResponse: MessageFns<ProvidersResponse>;
+export declare const ModelsResponse: MessageFns<ModelsResponse>;
+export declare const PricingResponse: MessageFns<PricingResponse>;
+export declare const ValidateEndpointResponse: MessageFns<ValidateEndpointResponse>;
+export declare const CreateEndpointResponse: MessageFns<CreateEndpointResponse>;
+export declare const UpdateEndpointResponse: MessageFns<UpdateEndpointResponse>;
+export declare const GetEndpointByIdResponse: MessageFns<GetEndpointByIdResponse>;
+export declare const ListEndpointsResponse: MessageFns<ListEndpointsResponse>;
+export declare const DeleteEndpointResponse: MessageFns<DeleteEndpointResponse>;
+export interface EndpointServiceClient {
+    /** Existing methods */
+    getEndpointConfig(request: EndpointRequest, metadata?: Metadata): Observable<EndpointConfig>;
+    getProviders(request: ProvidersRequest, metadata?: Metadata): Observable<ProvidersResponse>;
+    getModels(request: ModelsRequest, metadata?: Metadata): Observable<ModelsResponse>;
+    getPricing(request: PricingRequest, metadata?: Metadata): Observable<PricingResponse>;
+    validateEndpoint(request: ValidateEndpointRequest, metadata?: Metadata): Observable<ValidateEndpointResponse>;
+    /** CRUD methods for endpoints */
+    createEndpoint(request: CreateEndpointRequest, metadata?: Metadata): Observable<CreateEndpointResponse>;
+    updateEndpoint(request: UpdateEndpointRequest, metadata?: Metadata): Observable<UpdateEndpointResponse>;
+    getEndpointById(request: GetEndpointByIdRequest, metadata?: Metadata): Observable<GetEndpointByIdResponse>;
+    listEndpoints(request: ListEndpointsRequest, metadata?: Metadata): Observable<ListEndpointsResponse>;
+    deleteEndpoint(request: DeleteEndpointRequest, metadata?: Metadata): Observable<DeleteEndpointResponse>;
+}
+export interface EndpointServiceController {
+    /** Existing methods */
+    getEndpointConfig(request: EndpointRequest, metadata?: Metadata): Promise<EndpointConfig> | Observable<EndpointConfig> | EndpointConfig;
+    getProviders(request: ProvidersRequest, metadata?: Metadata): Promise<ProvidersResponse> | Observable<ProvidersResponse> | ProvidersResponse;
+    getModels(request: ModelsRequest, metadata?: Metadata): Promise<ModelsResponse> | Observable<ModelsResponse> | ModelsResponse;
+    getPricing(request: PricingRequest, metadata?: Metadata): Promise<PricingResponse> | Observable<PricingResponse> | PricingResponse;
+    validateEndpoint(request: ValidateEndpointRequest, metadata?: Metadata): Promise<ValidateEndpointResponse> | Observable<ValidateEndpointResponse> | ValidateEndpointResponse;
+    /** CRUD methods for endpoints */
+    createEndpoint(request: CreateEndpointRequest, metadata?: Metadata): Promise<CreateEndpointResponse> | Observable<CreateEndpointResponse> | CreateEndpointResponse;
+    updateEndpoint(request: UpdateEndpointRequest, metadata?: Metadata): Promise<UpdateEndpointResponse> | Observable<UpdateEndpointResponse> | UpdateEndpointResponse;
+    getEndpointById(request: GetEndpointByIdRequest, metadata?: Metadata): Promise<GetEndpointByIdResponse> | Observable<GetEndpointByIdResponse> | GetEndpointByIdResponse;
+    listEndpoints(request: ListEndpointsRequest, metadata?: Metadata): Promise<ListEndpointsResponse> | Observable<ListEndpointsResponse> | ListEndpointsResponse;
+    deleteEndpoint(request: DeleteEndpointRequest, metadata?: Metadata): Promise<DeleteEndpointResponse> | Observable<DeleteEndpointResponse> | DeleteEndpointResponse;
+}
+export declare function EndpointServiceControllerMethods(): (constructor: Function) => void;
+export declare const ENDPOINT_SERVICE_NAME = "EndpointService";
+export type EndpointServiceService = typeof EndpointServiceService;
+export declare const EndpointServiceService: {
+    /** Existing methods */
+    readonly getEndpointConfig: {
+        readonly path: "/endpoint.EndpointService/GetEndpointConfig";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: EndpointRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => EndpointRequest;
+        readonly responseSerialize: (value: EndpointConfig) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => EndpointConfig;
+    };
+    readonly getProviders: {
+        readonly path: "/endpoint.EndpointService/GetProviders";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ProvidersRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ProvidersRequest;
+        readonly responseSerialize: (value: ProvidersResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ProvidersResponse;
+    };
+    readonly getModels: {
+        readonly path: "/endpoint.EndpointService/GetModels";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ModelsRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ModelsRequest;
+        readonly responseSerialize: (value: ModelsResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ModelsResponse;
+    };
+    readonly getPricing: {
+        readonly path: "/endpoint.EndpointService/GetPricing";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: PricingRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => PricingRequest;
+        readonly responseSerialize: (value: PricingResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => PricingResponse;
+    };
+    readonly validateEndpoint: {
+        readonly path: "/endpoint.EndpointService/ValidateEndpoint";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ValidateEndpointRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ValidateEndpointRequest;
+        readonly responseSerialize: (value: ValidateEndpointResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ValidateEndpointResponse;
+    };
+    /** CRUD methods for endpoints */
+    readonly createEndpoint: {
+        readonly path: "/endpoint.EndpointService/CreateEndpoint";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: CreateEndpointRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => CreateEndpointRequest;
+        readonly responseSerialize: (value: CreateEndpointResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => CreateEndpointResponse;
+    };
+    readonly updateEndpoint: {
+        readonly path: "/endpoint.EndpointService/UpdateEndpoint";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: UpdateEndpointRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => UpdateEndpointRequest;
+        readonly responseSerialize: (value: UpdateEndpointResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => UpdateEndpointResponse;
+    };
+    readonly getEndpointById: {
+        readonly path: "/endpoint.EndpointService/GetEndpointById";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetEndpointByIdRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetEndpointByIdRequest;
+        readonly responseSerialize: (value: GetEndpointByIdResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => GetEndpointByIdResponse;
+    };
+    readonly listEndpoints: {
+        readonly path: "/endpoint.EndpointService/ListEndpoints";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ListEndpointsRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ListEndpointsRequest;
+        readonly responseSerialize: (value: ListEndpointsResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ListEndpointsResponse;
+    };
+    readonly deleteEndpoint: {
+        readonly path: "/endpoint.EndpointService/DeleteEndpoint";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: DeleteEndpointRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => DeleteEndpointRequest;
+        readonly responseSerialize: (value: DeleteEndpointResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => DeleteEndpointResponse;
+    };
+};
+export interface EndpointServiceServer extends UntypedServiceImplementation {
+    /** Existing methods */
+    getEndpointConfig: handleUnaryCall<EndpointRequest, EndpointConfig>;
+    getProviders: handleUnaryCall<ProvidersRequest, ProvidersResponse>;
+    getModels: handleUnaryCall<ModelsRequest, ModelsResponse>;
+    getPricing: handleUnaryCall<PricingRequest, PricingResponse>;
+    validateEndpoint: handleUnaryCall<ValidateEndpointRequest, ValidateEndpointResponse>;
+    /** CRUD methods for endpoints */
+    createEndpoint: handleUnaryCall<CreateEndpointRequest, CreateEndpointResponse>;
+    updateEndpoint: handleUnaryCall<UpdateEndpointRequest, UpdateEndpointResponse>;
+    getEndpointById: handleUnaryCall<GetEndpointByIdRequest, GetEndpointByIdResponse>;
+    listEndpoints: handleUnaryCall<ListEndpointsRequest, ListEndpointsResponse>;
+    deleteEndpoint: handleUnaryCall<DeleteEndpointRequest, DeleteEndpointResponse>;
+}
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+}