geniebox-shared-lib 1.0.74 → 2.0.0

package/dist/ai/ai.interface.d.ts

@@ -10,7 +10,7 @@ export interface AIStatusResponse {
     status: string;
     logs?: Array<{
         message: string;
-        level?: 'info' | 'warn' | 'error';
+        level?: "info" | "warn" | "error";
         timestamp?: string;
     }>;
 }

package/dist/ai/ai.interface.js

@@ -464,7 +464,13 @@ exports.AIStreamResponse = {
 };
 function AIServiceControllerMethods() {
     return function (constructor) {
-        const grpcMethods = ["call", "status", "result", "cancel", "stream"];
+        const grpcMethods = [
+            "call",
+            "status",
+            "result",
+            "cancel",
+            "stream",
+        ];
         for (const method of grpcMethods) {
             const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
             (0, microservices_1.GrpcMethod)("AIService", method)(constructor.prototype[method], method, descriptor);

package/dist/ai.client.d.ts

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

package/dist/ai.client.js

@@ -0,0 +1,42 @@
+"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 AIClient_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIClient = void 0;
+const common_1 = require("@nestjs/common");
+let AIClient = AIClient_1 = class AIClient {
+    constructor(client) {
+        this.client = client;
+        this.logger = new common_1.Logger(AIClient_1.name);
+    }
+    onModuleInit() {
+        this.aiClient = this.client.getService("AIService");
+        this.logger.log("AIServiceClient initialized");
+    }
+    get service() {
+        if (!this.aiClient) {
+            throw new common_1.InternalServerErrorException("AIService is not initialized yet");
+        }
+        return this.aiClient;
+    }
+    isReady() {
+        return !!this.aiClient;
+    }
+};
+exports.AIClient = AIClient;
+exports.AIClient = AIClient = AIClient_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)("AI_PACKAGE")),
+    __metadata("design:paramtypes", [Object])
+], AIClient);

package/dist/ai.interface.d.ts

@@ -0,0 +1,133 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import type { handleServerStreamingCall, handleUnaryCall, Metadata, UntypedServiceImplementation } from "@grpc/grpc-js";
+import { Observable } from "rxjs";
+export declare const protobufPackage = "ai";
+export interface AICallResponse {
+    requestId: string;
+}
+export interface AIStatusResponse {
+    requestId: string;
+    status: string;
+}
+export interface AIResultResponse {
+    requestId: string;
+    result: string;
+}
+export interface AICancelResponse {
+    requestId: string;
+    cancelled: boolean;
+}
+export interface AICallRequest {
+    endpoint: string;
+    payload: string;
+}
+export interface AIStatusRequest {
+    endpoint: string;
+    uuid: string;
+}
+export interface AIResultRequest {
+    endpoint: string;
+    uuid: string;
+}
+export interface AICancelRequest {
+    endpoint: string;
+    uuid: string;
+}
+export interface AIStreamRequest {
+    endpoint: string;
+    payload: string;
+}
+export interface AIStreamResponse {
+    requestId: string;
+    /** "start", "data", "log", "done", "error" */
+    type: string;
+    data: string;
+    chunk: number;
+    timestamp: string;
+}
+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 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>;
+}
+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>;
+}
+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 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 status: {
+        readonly path: "/ai.AIService/status";
+        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 result: {
+        readonly path: "/ai.AIService/result";
+        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 cancel: {
+        readonly path: "/ai.AIService/cancel";
+        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 stream: {
+        readonly path: "/ai.AIService/stream";
+        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;
+    };
+};
+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>;
+}
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+}