geniebox-shared-lib 2.4.2 → 2.4.4

package/dist/agent.interface.d.ts

@@ -20,6 +20,9 @@ export interface Agent {
     visibility: string;
     createdAt: string;
     updatedAt: string;
+    /** Optional denormalized fields for API Gateway to enrich responses */
+    userName?: string | undefined;
+    userAvatar?: string | undefined;
 }
 export interface CreateAgentRequest {
     userId: string;
@@ -50,6 +53,10 @@ export interface ListAgentsRequest {
     offset: number;
     /** Filter by visibility */
     visibility?: string | undefined;
+    /** frontend supports these high-level types: all | mine | shared | bookmarked */
+    type?: string | undefined;
+    /** comma-separated filters (e.g. types) */
+    filters?: string | undefined;
 }
 export interface DeleteAgentRequest {
     id: string;

package/dist/agent.interface.js

@@ -47,6 +47,12 @@ exports.Agent = {
         if (message.updatedAt !== "") {
             writer.uint32(74).string(message.updatedAt);
         }
+        if (message.userName !== undefined) {
+            writer.uint32(82).string(message.userName);
+        }
+        if (message.userAvatar !== undefined) {
+            writer.uint32(90).string(message.userAvatar);
+        }
         return writer;
     },
     decode(input, length) {
@@ -119,6 +125,20 @@ exports.Agent = {
                     message.updatedAt = reader.string();
                     continue;
                 }
+                case 10: {
+                    if (tag !== 82) {
+                        break;
+                    }
+                    message.userName = reader.string();
+                    continue;
+                }
+                case 11: {
+                    if (tag !== 90) {
+                        break;
+                    }
+                    message.userAvatar = reader.string();
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;
@@ -364,6 +384,12 @@ exports.ListAgentsRequest = {
         if (message.visibility !== undefined) {
             writer.uint32(34).string(message.visibility);
         }
+        if (message.type !== undefined) {
+            writer.uint32(42).string(message.type);
+        }
+        if (message.filters !== undefined) {
+            writer.uint32(50).string(message.filters);
+        }
         return writer;
     },
     decode(input, length) {
@@ -401,6 +427,20 @@ exports.ListAgentsRequest = {
                     message.visibility = reader.string();
                     continue;
                 }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.type = reader.string();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 50) {
+                        break;
+                    }
+                    message.filters = reader.string();
+                    continue;
+                }
             }
             if ((tag & 7) === 4 || tag === 0) {
                 break;

package/dist/chat.client.d.ts

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

package/dist/chat.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 ChatClient_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatClient = void 0;
+const common_1 = require("@nestjs/common");
+let ChatClient = ChatClient_1 = class ChatClient {
+    constructor(client) {
+        this.client = client;
+        this.logger = new common_1.Logger(ChatClient_1.name);
+    }
+    onModuleInit() {
+        this.chatClient =
+            this.client.getService("ChatService");
+        this.logger.log("ChatServiceClient initialized");
+    }
+    get service() {
+        if (!this.chatClient) {
+            throw new common_1.InternalServerErrorException("ChatService is not initialized yet");
+        }
+        return this.chatClient;
+    }
+    isReady() {
+        return !!this.chatClient;
+    }
+};
+exports.ChatClient = ChatClient;
+exports.ChatClient = ChatClient = ChatClient_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)("CHAT_PACKAGE")),
+    __metadata("design:paramtypes", [Object])
+], ChatClient);

package/dist/chat.interface.d.ts

@@ -0,0 +1,173 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import type { handleUnaryCall, Metadata, UntypedServiceImplementation } from "@grpc/grpc-js";
+import { Observable } from "rxjs";
+import { Empty } from "./google/protobuf/empty.interface";
+export declare const protobufPackage = "chat";
+export interface Chat {
+    id: string;
+    title: string;
+    userId: string;
+    metadata?: {
+        [key: string]: any;
+    } | undefined;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ChatMessage {
+    id: string;
+    chatId: string;
+    /** user, assistant, system */
+    role: string;
+    content: string;
+    metadata?: {
+        [key: string]: any;
+    } | undefined;
+    createdAt: string;
+}
+/** Requests */
+export interface CreateChatRequest {
+    userId: string;
+    title: string;
+    metadata?: {
+        [key: string]: any;
+    } | undefined;
+}
+export interface GetChatRequest {
+    id: string;
+    /** For authorization check */
+    userId: string;
+}
+export interface ListChatsRequest {
+    userId: string;
+    limit: number;
+    offset: number;
+}
+export interface DeleteChatRequest {
+    id: string;
+    /** For authorization check */
+    userId: string;
+}
+export interface AddMessageRequest {
+    chatId: string;
+    /** For authorization check */
+    userId: string;
+    role: string;
+    content: string;
+    metadata?: {
+        [key: string]: any;
+    } | undefined;
+}
+export interface GetMessagesRequest {
+    chatId: string;
+    /** For authorization check */
+    userId: string;
+    limit: number;
+    offset: number;
+}
+/** Responses */
+export interface ChatsResponse {
+    chats: Chat[];
+    total: number;
+}
+export interface MessagesResponse {
+    messages: ChatMessage[];
+    total: number;
+}
+export declare const CHAT_PACKAGE_NAME = "chat";
+export declare const Chat: MessageFns<Chat>;
+export declare const ChatMessage: MessageFns<ChatMessage>;
+export declare const CreateChatRequest: MessageFns<CreateChatRequest>;
+export declare const GetChatRequest: MessageFns<GetChatRequest>;
+export declare const ListChatsRequest: MessageFns<ListChatsRequest>;
+export declare const DeleteChatRequest: MessageFns<DeleteChatRequest>;
+export declare const AddMessageRequest: MessageFns<AddMessageRequest>;
+export declare const GetMessagesRequest: MessageFns<GetMessagesRequest>;
+export declare const ChatsResponse: MessageFns<ChatsResponse>;
+export declare const MessagesResponse: MessageFns<MessagesResponse>;
+export interface ChatServiceClient {
+    createChat(request: CreateChatRequest, metadata?: Metadata): Observable<Chat>;
+    getChat(request: GetChatRequest, metadata?: Metadata): Observable<Chat>;
+    listChats(request: ListChatsRequest, metadata?: Metadata): Observable<ChatsResponse>;
+    deleteChat(request: DeleteChatRequest, metadata?: Metadata): Observable<Empty>;
+    addMessage(request: AddMessageRequest, metadata?: Metadata): Observable<ChatMessage>;
+    getMessages(request: GetMessagesRequest, metadata?: Metadata): Observable<MessagesResponse>;
+}
+export interface ChatServiceController {
+    createChat(request: CreateChatRequest, metadata?: Metadata): Promise<Chat> | Observable<Chat> | Chat;
+    getChat(request: GetChatRequest, metadata?: Metadata): Promise<Chat> | Observable<Chat> | Chat;
+    listChats(request: ListChatsRequest, metadata?: Metadata): Promise<ChatsResponse> | Observable<ChatsResponse> | ChatsResponse;
+    deleteChat(request: DeleteChatRequest, metadata?: Metadata): void;
+    addMessage(request: AddMessageRequest, metadata?: Metadata): Promise<ChatMessage> | Observable<ChatMessage> | ChatMessage;
+    getMessages(request: GetMessagesRequest, metadata?: Metadata): Promise<MessagesResponse> | Observable<MessagesResponse> | MessagesResponse;
+}
+export declare function ChatServiceControllerMethods(): (constructor: Function) => void;
+export declare const CHAT_SERVICE_NAME = "ChatService";
+export type ChatServiceService = typeof ChatServiceService;
+export declare const ChatServiceService: {
+    readonly createChat: {
+        readonly path: "/chat.ChatService/createChat";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: CreateChatRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => CreateChatRequest;
+        readonly responseSerialize: (value: Chat) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Chat;
+    };
+    readonly getChat: {
+        readonly path: "/chat.ChatService/getChat";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetChatRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetChatRequest;
+        readonly responseSerialize: (value: Chat) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Chat;
+    };
+    readonly listChats: {
+        readonly path: "/chat.ChatService/listChats";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ListChatsRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ListChatsRequest;
+        readonly responseSerialize: (value: ChatsResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ChatsResponse;
+    };
+    readonly deleteChat: {
+        readonly path: "/chat.ChatService/deleteChat";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: DeleteChatRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => DeleteChatRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+    readonly addMessage: {
+        readonly path: "/chat.ChatService/addMessage";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: AddMessageRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => AddMessageRequest;
+        readonly responseSerialize: (value: ChatMessage) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ChatMessage;
+    };
+    readonly getMessages: {
+        readonly path: "/chat.ChatService/getMessages";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetMessagesRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetMessagesRequest;
+        readonly responseSerialize: (value: MessagesResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => MessagesResponse;
+    };
+};
+export interface ChatServiceServer extends UntypedServiceImplementation {
+    createChat: handleUnaryCall<CreateChatRequest, Chat>;
+    getChat: handleUnaryCall<GetChatRequest, Chat>;
+    listChats: handleUnaryCall<ListChatsRequest, ChatsResponse>;
+    deleteChat: handleUnaryCall<DeleteChatRequest, Empty>;
+    addMessage: handleUnaryCall<AddMessageRequest, ChatMessage>;
+    getMessages: handleUnaryCall<GetMessagesRequest, MessagesResponse>;
+}
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+}