@vectorx/agent-runtime 0.0.0-beta-20251112071515

package/lib/agent-runner.d.ts

@@ -0,0 +1,14 @@
+import type { IAgent } from "@vectorx/ai-sdk";
+import type { RcbContext } from "@vectorx/functions-framework";
+export declare class AgentDriver {
+    readonly agent: IAgent;
+    static run(event: unknown, context: RcbContext, agent: IAgent): Promise<unknown>;
+    constructor(agent: IAgent);
+    run(event: unknown, context: RcbContext): Promise<unknown>;
+    private sendMessageFunc;
+    private getHistoryMessagesFunc;
+    private getAgentInfoFunc;
+    private getConversationsFunc;
+    private queryTasksFunc;
+    private uploadFileFunc;
+}

package/lib/agent-runner.js

@@ -0,0 +1,123 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentDriver = void 0;
+const codes_1 = require("./codes");
+const schema_1 = require("./schema");
+const agent_helper_1 = require("./utils/agent-helper");
+const integration_response_1 = require("./utils/integration-response");
+class AgentDriver {
+    static run(event, context, agent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new AgentDriver(agent).run(event, context);
+        });
+    }
+    constructor(agent) {
+        this.agent = agent;
+    }
+    run(event, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!context.httpContext) {
+                return (0, integration_response_1.createIntegrationResponse)(400, codes_1.CODES.INVALID_HTTP_CONTEXT, "Invalid HTTP context");
+            }
+            const apiFuncs = {
+                "POST:send-message": this.sendMessageFunc.bind(this),
+                "POST:upload-openai-file": this.uploadFileFunc.bind(this),
+                "GET:query-tasks": this.queryTasksFunc.bind(this),
+                "GET:messages": this.getHistoryMessagesFunc.bind(this),
+                "GET:info": this.getAgentInfoFunc.bind(this),
+                "GET:conversations": this.getConversationsFunc.bind(this),
+                "GET:health": () => __awaiter(this, void 0, void 0, function* () { return ({ message: integration_response_1.OK_MESSAGE, timestamp: new Date().toISOString() }); }),
+            };
+            const httpMethod = context.httpContext.httpMethod;
+            const apiName = (0, agent_helper_1.parseApiName)(context.httpContext.url);
+            if (!apiName) {
+                return (0, integration_response_1.createIntegrationResponse)(404, codes_1.CODES.AGENT_API_NOT_FOUND, `Invalid url : ${context.httpContext.url}`);
+            }
+            const apiFunc = apiFuncs[`${httpMethod}:${apiName}`];
+            if (apiFunc) {
+                return apiFunc(event, context);
+            }
+            return (0, integration_response_1.createIntegrationResponse)(404, codes_1.CODES.AGENT_API_NOT_FOUND, `Agent API ${httpMethod}:${apiName} has not been supported`);
+        });
+    }
+    sendMessageFunc(event, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const parsedEvent = schema_1.sendMessageInputSchema.passthrough().parse(event);
+                return yield this.agent.sendMessage(parsedEvent);
+            }
+            catch (e) {
+                return (0, integration_response_1.createIntegrationResponse)(500, codes_1.CODES.AGENT_API_ERROR, `Agent API 'sendMessage' failed, message: ${e}`);
+            }
+        });
+    }
+    getHistoryMessagesFunc(event, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const query = (0, agent_helper_1.parseQueryFromCtx)(context);
+                const parsedEvent = schema_1.getHistoryMessagesParamsSchema.passthrough().parse(query);
+                return yield this.agent.getHistoryMessages(parsedEvent);
+            }
+            catch (e) {
+                return (0, integration_response_1.createIntegrationResponse)(500, codes_1.CODES.AGENT_API_ERROR, `Agent API 'getHistoryMessages' failed, message: ${e}`);
+            }
+        });
+    }
+    getAgentInfoFunc() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.agent.getAgentInfo();
+            }
+            catch (e) {
+                return (0, integration_response_1.createIntegrationResponse)(500, codes_1.CODES.AGENT_API_ERROR, `Agent API 'getAgentInfo' failed, message: ${e}`);
+            }
+        });
+    }
+    getConversationsFunc() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.agent.getConversations();
+            }
+            catch (e) {
+                return (0, integration_response_1.createIntegrationResponse)(500, codes_1.CODES.AGENT_API_ERROR, `Agent API 'getConversations' failed, message: ${e}`);
+            }
+        });
+    }
+    queryTasksFunc(event, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                const pathTaskId = (0, agent_helper_1.parseTaskIdFromPath)(context.httpContext.url);
+                const query = (0, agent_helper_1.parseQueryFromCtx)(context);
+                const parsed = schema_1.queryTasksParamsSchema.passthrough().parse({
+                    task_id: query.task_id || pathTaskId,
+                });
+                return yield ((_b = (_a = this.agent).queryTasks) === null || _b === void 0 ? void 0 : _b.call(_a, parsed.task_id));
+            }
+            catch (e) {
+                return (0, integration_response_1.createIntegrationResponse)(500, codes_1.CODES.AGENT_API_ERROR, `Agent API 'queryTasks' failed, message: ${e}`);
+            }
+        });
+    }
+    uploadFileFunc(event, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                return yield ((_b = (_a = this.agent).uploadFile) === null || _b === void 0 ? void 0 : _b.call(_a, event));
+            }
+            catch (e) {
+                return (0, integration_response_1.createIntegrationResponse)(500, codes_1.CODES.AGENT_API_ERROR, `Agent API 'uploadFile' failed, message: ${e}`);
+            }
+        });
+    }
+}
+exports.AgentDriver = AgentDriver;

package/lib/agent-types.d.ts

@@ -0,0 +1,118 @@
+import type { MessageType } from "@vectorx/ai-sdk";
+import type { BaseResponse } from "./utils/integration-response";
+export interface UserRecord {
+    content: string;
+    role: "user";
+}
+export interface AssistantRecord {
+    content: string;
+    role: "assistant";
+    reasoningContent: string;
+    type: MessageType;
+}
+export type CreateRecordPairResponse = BaseResponse;
+export interface ParticipantInfo {
+    id: string;
+    name: string;
+    desc: string;
+    avatar_url: string;
+}
+export interface GetHistoryMessagesData {
+    message_list: (UserRecord | AssistantRecord)[];
+    conversation_id: string;
+    participant_info_map: Record<string, ParticipantInfo>;
+    next_cursor: number;
+    has_more: boolean;
+}
+export type GetHistoryMessagesResponse = BaseResponse<GetHistoryMessagesData>;
+export interface Conversation {
+    id: string;
+    createAt: string;
+}
+export interface GetConversationsData {
+    conversations: Conversation[];
+}
+export type GetConversationsResponse = BaseResponse<GetConversationsData>;
+export type ChatRecordBase = {};
+export interface GetChatRecordsOutput {
+    recordList: ChatRecordBase[];
+    total: number;
+}
+export interface UserProfile {
+    tags?: string[];
+    preferences?: Record<string, any>;
+}
+export interface LoneMemoryRecord extends ChatRecordBase {
+    userProfile?: UserProfile;
+}
+export interface GetLoneMemoryOutput {
+    recordList: LoneMemoryRecord[];
+    total: number;
+}
+export interface KnowledgeResultMetaData {
+    score: number;
+    source_type: string;
+    doc_type: string;
+    content_length: number;
+}
+export interface KnowledgeResult {
+    id: string;
+    content: string;
+    chunk_id: string;
+    meta_data: KnowledgeResultMetaData;
+}
+export interface KnowledgeSearchOutput {
+    knowledge_results: KnowledgeResult[];
+    total_tokens: number;
+}
+export type KnowledgeBaseRetrieveResponse = BaseResponse<KnowledgeSearchOutput>;
+export interface AgentInfo {
+    agentId: string;
+    version: string;
+    desc: string;
+}
+export interface GetAgentInfoResponse {
+    code: number;
+    success: boolean;
+    msg: string;
+    data: {
+        agentInfo: AgentInfo;
+    };
+}
+export interface QueryTasksData {
+    request_id: string;
+    output: {
+        task_id: string;
+        task_status: "PENDING" | "RUNNING" | "SUCCEEDED" | "FAILED" | "CANCELED" | "UNKNOWN";
+        results?: Array<{
+            url?: string;
+            [key: string]: any;
+        }>;
+        task_metrics?: {
+            TOTAL: number;
+            SUCCEEDED: number;
+            FAILED: number;
+        };
+    };
+    usage?: {
+        image_count?: number;
+    };
+}
+export type RawQueryTasksResponse = QueryTasksData;
+export type QueryTasksResponse = BaseResponse<QueryTasksData>;
+export interface UploadFileInput {
+    file: File | Buffer | string;
+    filename: string;
+    purpose?: string;
+}
+export interface UploadFileData {
+    id: string;
+    object: string;
+    bytes: number;
+    created_at: number;
+    filename: string;
+    purpose: string;
+    status: string;
+    status_details?: any;
+}
+export type UploadFileResponse = BaseResponse<UploadFileData>;

package/lib/agent-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/agent.d.ts

@@ -0,0 +1,40 @@
+import { type AI, type models } from "@vectorx/ai-sdk";
+import { type RcbContext } from "@vectorx/functions-framework";
+import type { CreateRecordPairResponse, GetAgentInfoResponse, GetConversationsResponse, GetHistoryMessagesResponse, KnowledgeBaseRetrieveResponse, QueryTasksResponse, UploadFileResponse } from "./agent-types";
+import { type CreateRecordPairParams, type GetHistoryMessagesParams, type KnowledgeSearchInput } from "./schema";
+import { SSESender } from "./sse-sender";
+export declare enum AgentType {
+    AI_SDK_REQUEST_START = "AI_SDK_REQUEST_START",
+    AI_SDK_REQUEST_SUCCESS = "AI_SDK_REQUEST_SUCCESS",
+    AI_SDK_REQUEST_ERROR = "AI_SDK_REQUEST_ERROR",
+    AI_SDK_CREATE_MODEL = "AI_SDK_CREATE_MODEL",
+    AI_SDK_CREATE_RECORD_PAIR = "AI_SDK_CREATE_RECORD_PAIR",
+    AI_SDK_GET_HISTORY_MESSAGES = "AI_SDK_GET_HISTORY_MESSAGES",
+    AI_SDK_GET_CONVERSATIONS = "AI_SDK_GET_CONVERSATIONS",
+    Ai_SDK_POST_KNOWLEDGE_BASE = "Ai_SDK_POST_KNOWLEDGE_BASE",
+    AI_SDK_QUERY_TASKS = "AI_SDK_QUERY_TASKS"
+}
+export declare enum AgentEventType {
+    FRAMEWORK_EVENT = "FRAMEWORK_EVENT",
+    HTTP_ACCESS = "HTTP_ACCESS"
+}
+export declare class AgentRuntime {
+    readonly context: RcbContext;
+    sseSender: SSESender<unknown>;
+    protected ai: AI;
+    protected request: RcbContext["request"];
+    protected logger: RcbContext["logger"];
+    get agentTag(): string;
+    get agentId(): string;
+    get version(): string;
+    constructor(context: RcbContext);
+    private createLoggedRequest;
+    protected createModel(modelName: models.ModelName): models.ReActModel;
+    protected createRecordPair(params: CreateRecordPairParams): Promise<CreateRecordPairResponse>;
+    protected getHistoryMessages(params: GetHistoryMessagesParams): Promise<GetHistoryMessagesResponse>;
+    protected getConversations(): Promise<GetConversationsResponse>;
+    getAgentInfo(): Promise<GetAgentInfoResponse>;
+    knowledgeBaseRetrieve(params: KnowledgeSearchInput): Promise<KnowledgeBaseRetrieveResponse>;
+    queryTasks(task_id?: string): Promise<QueryTasksResponse>;
+    uploadFile(input: any): Promise<UploadFileResponse>;
+}