geniebox-shared-lib 2.3.0 → 2.4.0

package/dist/agent.client.d.ts

@@ -0,0 +1,11 @@
+import { OnModuleInit } from "@nestjs/common";
+import { ClientGrpc } from "@nestjs/microservices";
+import { AgentServiceClient } from "./agent.interface";
+export declare class AgentClient implements OnModuleInit {
+    private readonly client;
+    private readonly logger;
+    private agentClient?;
+    constructor(client: ClientGrpc);
+    onModuleInit(): void;
+    get service(): AgentServiceClient;
+}

package/dist/agent.client.js

@@ -0,0 +1,45 @@
+"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 AgentClient_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentClient = void 0;
+const common_1 = require("@nestjs/common");
+let AgentClient = AgentClient_1 = class AgentClient {
+    constructor(client) {
+        this.client = client;
+        this.logger = new common_1.Logger(AgentClient_1.name);
+    }
+    onModuleInit() {
+        this.agentClient =
+            this.client.getService("AgentService");
+        if (!this.agentClient) {
+            this.logger.error("Failed to initialize AgentServiceClient");
+            throw new Error("AgentServiceClient initialization failed");
+        }
+        this.logger.log("AgentServiceClient initialized successfully");
+    }
+    get service() {
+        if (!this.agentClient) {
+            this.logger.error("Tried to access AgentService before initialization");
+            throw new Error("AgentServiceClient not initialized yet");
+        }
+        return this.agentClient;
+    }
+};
+exports.AgentClient = AgentClient;
+exports.AgentClient = AgentClient = AgentClient_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)("AGENT_PACKAGE")),
+    __metadata("design:paramtypes", [Object])
+], AgentClient);

package/dist/agent.interface.d.ts

@@ -0,0 +1,140 @@
+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 = "agent";
+export interface Agent {
+    id: string;
+    name: string;
+    description: string;
+    /** JSON string */
+    icon: string;
+    userId: string;
+    /** JSON string */
+    instructions: string;
+    /** "public", "private", "readonly" */
+    visibility: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateAgentRequest {
+    userId: string;
+    name: string;
+    description: string;
+    icon: string;
+    instructions: string;
+    visibility: string;
+}
+export interface UpdateAgentRequest {
+    id: string;
+    /** For authorization check */
+    userId: string;
+    name?: string | undefined;
+    description?: string | undefined;
+    icon?: string | undefined;
+    instructions?: string | undefined;
+    visibility?: string | undefined;
+}
+export interface GetAgentRequest {
+    id: string;
+    /** For visibility check */
+    userId: string;
+}
+export interface ListAgentsRequest {
+    userId: string;
+    limit: number;
+    offset: number;
+    /** Filter by visibility */
+    visibility?: string | undefined;
+}
+export interface DeleteAgentRequest {
+    id: string;
+    userId: string;
+}
+export interface AgentsResponse {
+    agents: Agent[];
+    total: number;
+}
+export declare const AGENT_PACKAGE_NAME = "agent";
+export declare const Agent: MessageFns<Agent>;
+export declare const CreateAgentRequest: MessageFns<CreateAgentRequest>;
+export declare const UpdateAgentRequest: MessageFns<UpdateAgentRequest>;
+export declare const GetAgentRequest: MessageFns<GetAgentRequest>;
+export declare const ListAgentsRequest: MessageFns<ListAgentsRequest>;
+export declare const DeleteAgentRequest: MessageFns<DeleteAgentRequest>;
+export declare const AgentsResponse: MessageFns<AgentsResponse>;
+export interface AgentServiceClient {
+    createAgent(request: CreateAgentRequest, metadata?: Metadata): Observable<Agent>;
+    getAgent(request: GetAgentRequest, metadata?: Metadata): Observable<Agent>;
+    updateAgent(request: UpdateAgentRequest, metadata?: Metadata): Observable<Agent>;
+    deleteAgent(request: DeleteAgentRequest, metadata?: Metadata): Observable<Empty>;
+    listAgents(request: ListAgentsRequest, metadata?: Metadata): Observable<AgentsResponse>;
+}
+export interface AgentServiceController {
+    createAgent(request: CreateAgentRequest, metadata?: Metadata): Promise<Agent> | Observable<Agent> | Agent;
+    getAgent(request: GetAgentRequest, metadata?: Metadata): Promise<Agent> | Observable<Agent> | Agent;
+    updateAgent(request: UpdateAgentRequest, metadata?: Metadata): Promise<Agent> | Observable<Agent> | Agent;
+    deleteAgent(request: DeleteAgentRequest, metadata?: Metadata): void;
+    listAgents(request: ListAgentsRequest, metadata?: Metadata): Promise<AgentsResponse> | Observable<AgentsResponse> | AgentsResponse;
+}
+export declare function AgentServiceControllerMethods(): (constructor: Function) => void;
+export declare const AGENT_SERVICE_NAME = "AgentService";
+export type AgentServiceService = typeof AgentServiceService;
+export declare const AgentServiceService: {
+    readonly createAgent: {
+        readonly path: "/agent.AgentService/createAgent";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: CreateAgentRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => CreateAgentRequest;
+        readonly responseSerialize: (value: Agent) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Agent;
+    };
+    readonly getAgent: {
+        readonly path: "/agent.AgentService/getAgent";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: GetAgentRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => GetAgentRequest;
+        readonly responseSerialize: (value: Agent) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Agent;
+    };
+    readonly updateAgent: {
+        readonly path: "/agent.AgentService/updateAgent";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: UpdateAgentRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => UpdateAgentRequest;
+        readonly responseSerialize: (value: Agent) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Agent;
+    };
+    readonly deleteAgent: {
+        readonly path: "/agent.AgentService/deleteAgent";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: DeleteAgentRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => DeleteAgentRequest;
+        readonly responseSerialize: (value: Empty) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Empty;
+    };
+    readonly listAgents: {
+        readonly path: "/agent.AgentService/listAgents";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ListAgentsRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ListAgentsRequest;
+        readonly responseSerialize: (value: AgentsResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => AgentsResponse;
+    };
+};
+export interface AgentServiceServer extends UntypedServiceImplementation {
+    createAgent: handleUnaryCall<CreateAgentRequest, Agent>;
+    getAgent: handleUnaryCall<GetAgentRequest, Agent>;
+    updateAgent: handleUnaryCall<UpdateAgentRequest, Agent>;
+    deleteAgent: handleUnaryCall<DeleteAgentRequest, Empty>;
+    listAgents: handleUnaryCall<ListAgentsRequest, AgentsResponse>;
+}
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+}