geniebox-shared-lib 2.0.2 → 2.1.0

package/dist/ai.interface.d.ts

@@ -1,131 +1,184 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
-import type { handleServerStreamingCall, handleUnaryCall, Metadata, UntypedServiceImplementation } from "@grpc/grpc-js";
+import type { handleUnaryCall, Metadata, UntypedServiceImplementation } from "@grpc/grpc-js";
 import { Observable } from "rxjs";
 export declare const protobufPackage = "ai";
-export interface AICallResponse {
-    requestId: string;
+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 AIStatusResponse {
-    requestId: string;
-    status: 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 AIResultResponse {
-    requestId: string;
-    result: 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 AICancelResponse {
-    requestId: string;
-    cancelled: boolean;
+export interface EndpointConfig {
+    id: string;
+    path: string;
+    providerId: string;
+    providerName: string;
+    queueName: string;
+    methods: string[];
+    description: string;
+    isActive: boolean;
+    /** JSON string */
+    metadata: string;
 }
-export interface AICallRequest {
-    endpoint: string;
-    payload: string;
+export interface EndpointRequest {
+    /** e.g.: /openai/create */
+    path: string;
 }
-export interface AIStatusRequest {
-    endpoint: string;
-    uuid: string;
+export interface ProvidersRequest {
+    /** only active providers */
+    activeOnly: boolean;
 }
-export interface AIResultRequest {
-    endpoint: string;
-    uuid: string;
+export interface ModelsRequest {
+    /** filter by provider */
+    providerId: string;
+    /** only active models */
+    activeOnly: boolean;
 }
-export interface AICancelRequest {
-    endpoint: string;
-    uuid: string;
+export interface PricingRequest {
+    /** filter by model */
+    modelId: string;
+    /** currency (USD, EUR, etc.) */
+    currency: string;
 }
-export interface AIStreamRequest {
-    endpoint: string;
-    payload: string;
+export interface ValidateEndpointRequest {
+    path: string;
+    /** GET, POST, etc. */
+    method: string;
 }
-export interface AIStreamResponse {
-    requestId: string;
-    /** "start", "data", "log", "done", "error" */
-    type: string;
-    data: string;
-    chunk: number;
-    timestamp: string;
+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 declare const AI_PACKAGE_NAME = "ai";
-export declare const AICallResponse: MessageFns<AICallResponse>;
-export declare const AIStatusResponse: MessageFns<AIStatusResponse>;
-export declare const AIResultResponse: MessageFns<AIResultResponse>;
-export declare const AICancelResponse: MessageFns<AICancelResponse>;
-export declare const AICallRequest: MessageFns<AICallRequest>;
-export declare const AIStatusRequest: MessageFns<AIStatusRequest>;
-export declare const AIResultRequest: MessageFns<AIResultRequest>;
-export declare const AICancelRequest: MessageFns<AICancelRequest>;
-export declare const AIStreamRequest: MessageFns<AIStreamRequest>;
-export declare const AIStreamResponse: MessageFns<AIStreamResponse>;
+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 ProvidersResponse: MessageFns<ProvidersResponse>;
+export declare const ModelsResponse: MessageFns<ModelsResponse>;
+export declare const PricingResponse: MessageFns<PricingResponse>;
+export declare const ValidateEndpointResponse: MessageFns<ValidateEndpointResponse>;
 export interface AIServiceClient {
-    call(request: AICallRequest, metadata?: Metadata): Observable<AICallResponse>;
-    status(request: AIStatusRequest, metadata?: Metadata): Observable<AIStatusResponse>;
-    result(request: AIResultRequest, metadata?: Metadata): Observable<AIResultResponse>;
-    cancel(request: AICancelRequest, metadata?: Metadata): Observable<AICancelResponse>;
-    stream(request: AIStreamRequest, metadata?: Metadata): Observable<AIStreamResponse>;
+    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>;
 }
 export interface AIServiceController {
-    call(request: AICallRequest, metadata?: Metadata): Promise<AICallResponse> | Observable<AICallResponse> | AICallResponse;
-    status(request: AIStatusRequest, metadata?: Metadata): Promise<AIStatusResponse> | Observable<AIStatusResponse> | AIStatusResponse;
-    result(request: AIResultRequest, metadata?: Metadata): Promise<AIResultResponse> | Observable<AIResultResponse> | AIResultResponse;
-    cancel(request: AICancelRequest, metadata?: Metadata): Promise<AICancelResponse> | Observable<AICancelResponse> | AICancelResponse;
-    stream(request: AIStreamRequest, metadata?: Metadata): Observable<AIStreamResponse>;
+    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;
 }
 export declare function AIServiceControllerMethods(): (constructor: Function) => void;
 export declare const AI_SERVICE_NAME = "AIService";
 export type AIServiceService = typeof AIServiceService;
 export declare const AIServiceService: {
-    readonly call: {
-        readonly path: "/ai.AIService/call";
+    readonly getEndpointConfig: {
+        readonly path: "/ai.AIService/GetEndpointConfig";
         readonly requestStream: false;
         readonly responseStream: false;
-        readonly requestSerialize: (value: AICallRequest) => Buffer;
-        readonly requestDeserialize: (value: Buffer) => AICallRequest;
-        readonly responseSerialize: (value: AICallResponse) => Buffer;
-        readonly responseDeserialize: (value: Buffer) => AICallResponse;
+        readonly requestSerialize: (value: EndpointRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => EndpointRequest;
+        readonly responseSerialize: (value: EndpointConfig) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => EndpointConfig;
     };
-    readonly status: {
-        readonly path: "/ai.AIService/status";
+    readonly getProviders: {
+        readonly path: "/ai.AIService/GetProviders";
         readonly requestStream: false;
         readonly responseStream: false;
-        readonly requestSerialize: (value: AIStatusRequest) => Buffer;
-        readonly requestDeserialize: (value: Buffer) => AIStatusRequest;
-        readonly responseSerialize: (value: AIStatusResponse) => Buffer;
-        readonly responseDeserialize: (value: Buffer) => AIStatusResponse;
+        readonly requestSerialize: (value: ProvidersRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ProvidersRequest;
+        readonly responseSerialize: (value: ProvidersResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ProvidersResponse;
     };
-    readonly result: {
-        readonly path: "/ai.AIService/result";
+    readonly getModels: {
+        readonly path: "/ai.AIService/GetModels";
         readonly requestStream: false;
         readonly responseStream: false;
-        readonly requestSerialize: (value: AIResultRequest) => Buffer;
-        readonly requestDeserialize: (value: Buffer) => AIResultRequest;
-        readonly responseSerialize: (value: AIResultResponse) => Buffer;
-        readonly responseDeserialize: (value: Buffer) => AIResultResponse;
+        readonly requestSerialize: (value: ModelsRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ModelsRequest;
+        readonly responseSerialize: (value: ModelsResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ModelsResponse;
     };
-    readonly cancel: {
-        readonly path: "/ai.AIService/cancel";
+    readonly getPricing: {
+        readonly path: "/ai.AIService/GetPricing";
         readonly requestStream: false;
         readonly responseStream: false;
-        readonly requestSerialize: (value: AICancelRequest) => Buffer;
-        readonly requestDeserialize: (value: Buffer) => AICancelRequest;
-        readonly responseSerialize: (value: AICancelResponse) => Buffer;
-        readonly responseDeserialize: (value: Buffer) => AICancelResponse;
+        readonly requestSerialize: (value: PricingRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => PricingRequest;
+        readonly responseSerialize: (value: PricingResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => PricingResponse;
     };
-    readonly stream: {
-        readonly path: "/ai.AIService/stream";
+    readonly validateEndpoint: {
+        readonly path: "/ai.AIService/ValidateEndpoint";
         readonly requestStream: false;
-        readonly responseStream: true;
-        readonly requestSerialize: (value: AIStreamRequest) => Buffer;
-        readonly requestDeserialize: (value: Buffer) => AIStreamRequest;
-        readonly responseSerialize: (value: AIStreamResponse) => Buffer;
-        readonly responseDeserialize: (value: Buffer) => AIStreamResponse;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ValidateEndpointRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ValidateEndpointRequest;
+        readonly responseSerialize: (value: ValidateEndpointResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ValidateEndpointResponse;
     };
 };
 export interface AIServiceServer extends UntypedServiceImplementation {
-    call: handleUnaryCall<AICallRequest, AICallResponse>;
-    status: handleUnaryCall<AIStatusRequest, AIStatusResponse>;
-    result: handleUnaryCall<AIResultRequest, AIResultResponse>;
-    cancel: handleUnaryCall<AICancelRequest, AICancelResponse>;
-    stream: handleServerStreamingCall<AIStreamRequest, AIStreamResponse>;
+    getEndpointConfig: handleUnaryCall<EndpointRequest, EndpointConfig>;
+    getProviders: handleUnaryCall<ProvidersRequest, ProvidersResponse>;
+    getModels: handleUnaryCall<ModelsRequest, ModelsResponse>;
+    getPricing: handleUnaryCall<PricingRequest, PricingResponse>;
+    validateEndpoint: handleUnaryCall<ValidateEndpointRequest, ValidateEndpointResponse>;
 }
 export interface MessageFns<T> {
     encode(message: T, writer?: BinaryWriter): BinaryWriter;