@vectorx/functions-framework 0.1.3 → 0.3.0

package/bin/rcb-ff.js

@@ -20,6 +20,7 @@ program
     .option('--enable-cors', '启用 CORS')
     .option('--allowed-origins <origins>', 'CORS 允许的域名，用逗号分隔', 'localhost,127.0.0.1')
     .option('--config <path>', '指定配置文件路径', 'agent-cloudbase-functions.json')
+    .option('--enableRedLangfuse', '启用 Red Langfuse 上报')
     .option('-w, --watch', '启用文件监听模式，文件变化时自动重启服务');
 
 program.parse();
@@ -45,6 +46,9 @@ async function startServer() {
             functionsConfigFile: path.resolve(directory, options.config),
             enableCors: options.enableCors,
             allowedOrigins: options.allowedOrigins.split(','),
+            redLangfuseConfig: {
+                enable: Boolean(options.enableRedLangfuse),
+            },
             kitInfo: {
                 agentRuntimeVersion: getDependencyVersion('@vectorx/agent-runtime', directory),
                 functionsFrameworkVersion: getDependencyVersion('@vectorx/functions-framework', directory)

package/lib/config.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBaseUrl = getBaseUrl;
 const ENV_BASE_URL = {
-    development: "https://agentbase-sandbox.xiaohongshu.com",
+    development: "https://agentbase-sandbox.beta.xiaohongshu.com",
     production: "https://agentbase.xiaohongshu.com",
 };
 function getBaseUrl() {

package/lib/function-wrapper.js

@@ -79,11 +79,11 @@ const wrapEventFunction = (execute, projectConfig) => {
         ctx.state.event = event;
         ctx.state.contextInjected = frozenContext;
         let result;
-        const start = Date.now();
         try {
             result = yield execute(event, context);
         }
         catch (e) {
+            console.log("============>>>>>>>>>> function wrapper error ", e);
             ctx.state.error = e;
             if (hasSwitchSSEMode) {
                 const sse = (_a = ctx.sse) === null || _a === void 0 ? void 0 : _a.call(ctx);
@@ -93,14 +93,13 @@ const wrapEventFunction = (execute, projectConfig) => {
                         data: e.message,
                         comment: "uncaught-exception-from-user-code",
                     };
+                    console.log("============>>>>>>>>>> errorEvent ", errorEvent);
                     sse.emit("error", errorEvent);
+                    console.log("============>>>>>>>>>> sse.end(errorEvent) ");
                     sse.end(errorEvent);
                 }
             }
         }
-        finally {
-            ctx.state.userCodeTimeCost = Date.now() - start;
-        }
         executeDone = true;
         if (hasSwitchSSEMode) {
             return;

package/lib/logger.js

@@ -131,6 +131,50 @@ class FunctionsLogger {
             return logs;
         });
     }
+    getLogsPaginated(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { type, pageNum = 1, pageSize = 50 } = options;
+            const allLogs = yield this.getAllLogs(type);
+            const total = allLogs.length;
+            const offset = (pageNum - 1) * pageSize;
+            const logs = allLogs.slice(offset, offset + pageSize);
+            const hasMore = pageNum * pageSize < total;
+            return {
+                logs,
+                pageNum,
+                pageSize: logs.length,
+                total,
+                hasMore,
+            };
+        });
+    }
+    getAllLogs(type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const logs = [];
+            const logDir = DEFAULT_LOG_DIRNAME;
+            const files = fs_1.default
+                .readdirSync(logDir)
+                .filter((file) => file.startsWith(type) && file.endsWith(".log"))
+                .sort()
+                .reverse();
+            let globalId = 0;
+            for (const file of files) {
+                const content = fs_1.default.readFileSync(path_1.default.join(logDir, file), "utf-8");
+                const lines = content.split("\n").filter(Boolean).reverse();
+                for (const line of lines) {
+                    try {
+                        const log = JSON.parse(line);
+                        log.id = globalId++;
+                        logs.push(log);
+                    }
+                    catch (e) {
+                        console.error("Failed to parse log line:", line);
+                    }
+                }
+            }
+            return logs;
+        });
+    }
     createWinstonLogger(options) {
         const transports = [
             new winston_daily_rotate_file_1.default({

package/lib/middlewares/middle-logs-request.js

@@ -16,32 +16,82 @@ function logsQueryMiddleware() {
     return (ctx, next) => __awaiter(this, void 0, void 0, function* () {
         if (ctx.path.startsWith("/@logs")) {
             const type = ctx.query.type || logger_1.LogType.ACCESS;
+            const pageNumParam = ctx.query.pageNum;
+            const pageSizeParam = ctx.query.pageSize;
             const limitParam = ctx.query.limit;
-            const limit = limitParam ? Number.parseInt(limitParam) : 100;
-            if (Number.isNaN(limit) || limit <= 0 || limit > 1000) {
-                ctx.status = 400;
-                ctx.body = {
-                    success: false,
-                    error: "Invalid limit parameter. Must be a positive number <= 1000",
-                };
+            if (pageNumParam !== undefined || pageSizeParam !== undefined) {
+                const pageNum = pageNumParam ? Number.parseInt(pageNumParam) : 1;
+                const pageSize = pageSizeParam ? Number.parseInt(pageSizeParam) : 50;
+                if (Number.isNaN(pageNum) || pageNum <= 0) {
+                    ctx.status = 400;
+                    ctx.body = {
+                        success: false,
+                        error: "Invalid pageNum parameter. Must be a positive number.",
+                    };
+                    return;
+                }
+                if (Number.isNaN(pageSize) || pageSize <= 0 || pageSize > 100) {
+                    ctx.status = 400;
+                    ctx.body = {
+                        success: false,
+                        error: "Invalid pageSize parameter. Must be a positive number <= 100",
+                    };
+                    return;
+                }
+                try {
+                    const result = yield logger_2.functionsLogger.getLogsPaginated({
+                        type,
+                        pageNum,
+                        pageSize,
+                    });
+                    ctx.body = {
+                        success: true,
+                        data: result.logs,
+                        pagination: {
+                            pageNum: result.pageNum,
+                            pageSize: result.pageSize,
+                            total: result.total,
+                            hasMore: result.hasMore,
+                        },
+                    };
+                }
+                catch (error) {
+                    logger_2.functionsLogger.logError(error);
+                    ctx.status = 500;
+                    ctx.body = {
+                        success: false,
+                        error: error.message,
+                    };
+                }
                 return;
             }
-            try {
-                const logs = yield logger_2.functionsLogger.getLogs(type, limit);
-                ctx.body = {
-                    success: true,
-                    data: logs,
-                };
-            }
-            catch (error) {
-                logger_2.functionsLogger.logError(error);
-                ctx.status = 500;
-                ctx.body = {
-                    success: false,
-                    error: error.message,
-                };
+            else {
+                const limit = limitParam ? Number.parseInt(limitParam) : 100;
+                if (Number.isNaN(limit) || limit <= 0 || limit > 1000) {
+                    ctx.status = 400;
+                    ctx.body = {
+                        success: false,
+                        error: "Invalid limit parameter. Must be a positive number <= 1000",
+                    };
+                    return;
+                }
+                try {
+                    const logs = yield logger_2.functionsLogger.getLogs(type, limit);
+                    ctx.body = {
+                        success: true,
+                        data: logs,
+                    };
+                }
+                catch (error) {
+                    logger_2.functionsLogger.logError(error);
+                    ctx.status = 500;
+                    ctx.body = {
+                        success: false,
+                        error: error.message,
+                    };
+                }
+                return;
             }
-            return;
         }
         return yield next();
     });

package/lib/sse.js

@@ -32,15 +32,20 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ServerSentEvent = void 0;
 const events_1 = require("events");
 const stream_1 = require("stream");
 const util = __importStar(require("util"));
+const langfuse_1 = __importDefault(require("./telemetry/langfuse"));
 const helper_1 = require("./utils/helper");
 const kDefaultEncoder = new util.TextEncoder();
 class ServerSentEvent extends events_1.EventEmitter {
     constructor(ctx) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         super();
         this.closed = false;
         this.encoder = kDefaultEncoder;
@@ -77,6 +82,36 @@ class ServerSentEvent extends events_1.EventEmitter {
                 writable: false,
             });
         }
+        try {
+            const enabled = ((_c = (_b = (_a = ctx.state) === null || _a === void 0 ? void 0 : _a.frameworkOptions) === null || _b === void 0 ? void 0 : _b.redLangfuseConfig) === null || _c === void 0 ? void 0 : _c.enable) === true;
+            if (!enabled)
+                return;
+            const stage = process.env.OPEN_PLATFORM_STAGE || "development";
+            const openId = ctx.headers["open-id"] || undefined;
+            const eventID = (_d = ctx.state) === null || _d === void 0 ? void 0 : _d.eventID;
+            const agentInfo = ((_e = ctx.state) === null || _e === void 0 ? void 0 : _e.agentInfo) || {};
+            const name = [(agentInfo === null || agentInfo === void 0 ? void 0 : agentInfo.agentName) || (agentInfo === null || agentInfo === void 0 ? void 0 : agentInfo.name), agentInfo === null || agentInfo === void 0 ? void 0 : agentInfo.version].filter(Boolean).join("@");
+            const metadata = {
+                http: { method: ctx.method, path: ctx.path },
+                eventID,
+                agent: {
+                    id: agentInfo === null || agentInfo === void 0 ? void 0 : agentInfo.agentId,
+                    name: (agentInfo === null || agentInfo === void 0 ? void 0 : agentInfo.agentName) || (agentInfo === null || agentInfo === void 0 ? void 0 : agentInfo.name),
+                    version: agentInfo === null || agentInfo === void 0 ? void 0 : agentInfo.version,
+                },
+            };
+            const trace = (_f = langfuse_1.default === null || langfuse_1.default === void 0 ? void 0 : langfuse_1.default.trace) === null || _f === void 0 ? void 0 : _f.call(langfuse_1.default, {
+                name: name || "chat-app-session",
+                userId: openId,
+                tags: [stage],
+                metadata,
+            });
+            if (trace) {
+                ctx.state.langfuseTrace = trace;
+                (_g = trace.event) === null || _g === void 0 ? void 0 : _g.call(trace, { name: "sse:start", input: (_j = (_h = ctx.state) === null || _h === void 0 ? void 0 : _h.event) !== null && _j !== void 0 ? _j : null, metadata: { path: ctx.path } });
+            }
+        }
+        catch (_k) { }
     }
     setEncoder(encoder) {
         this.encoder = encoder;
@@ -94,6 +129,7 @@ class ServerSentEvent extends events_1.EventEmitter {
         return super.emit(event, ...args);
     }
     send(event) {
+        var _a, _b, _c;
         const encoder = this.encoder;
         const stream = this.stream;
         if (this.closed) {
@@ -122,17 +158,63 @@ class ServerSentEvent extends events_1.EventEmitter {
         }
         const buf = Buffer.concat(bufs);
         if (Buffer.byteLength(buf) > 0) {
-            return stream.write(Buffer.concat(bufs));
+            const ok = stream.write(Buffer.concat(bufs));
+            try {
+                const lfTrace = (_a = this.ctx.state) === null || _a === void 0 ? void 0 : _a.langfuseTrace;
+                if (lfTrace) {
+                    let output = null;
+                    try {
+                        if (!Array.isArray(event)) {
+                            if (typeof event === "string")
+                                output = event;
+                            else if (Buffer.isBuffer(event))
+                                output = event.toString("utf-8");
+                            else if ((0, helper_1.isPlainObject)(event))
+                                output = (_b = event.data) !== null && _b !== void 0 ? _b : null;
+                        }
+                        else {
+                            const last = event[event.length - 1];
+                            if (typeof last === "string")
+                                output = last;
+                            else if (Buffer.isBuffer(last))
+                                output = last.toString("utf-8");
+                            else if ((0, helper_1.isPlainObject)(last))
+                                output = (_c = last.data) !== null && _c !== void 0 ? _c : null;
+                        }
+                    }
+                    catch (_d) { }
+                    lfTrace.event({
+                        name: "sse:send",
+                        input: null,
+                        output,
+                        metadata: { size: Buffer.byteLength(buf) },
+                    });
+                }
+            }
+            catch (_e) { }
+            return ok;
         }
         return false;
     }
     end(msg) {
+        var _a, _b, _c, _d, _e, _f;
         if (msg) {
             this.send(msg);
         }
         this.stream.end();
         this.ctx.res.end();
         this.closed = true;
+        try {
+            const lfTrace = (_a = this.ctx.state) === null || _a === void 0 ? void 0 : _a.langfuseTrace;
+            const enabled = ((_d = (_c = (_b = this.ctx.state) === null || _b === void 0 ? void 0 : _b.frameworkOptions) === null || _c === void 0 ? void 0 : _c.redLangfuseConfig) === null || _d === void 0 ? void 0 : _d.enable) === true;
+            if (lfTrace) {
+                lfTrace.event({ name: "sse:end", input: null, output: null });
+            }
+            if (enabled && (langfuse_1.default === null || langfuse_1.default === void 0 ? void 0 : langfuse_1.default.shutdownAsync)) {
+                (_f = (_e = langfuse_1.default).shutdownAsync) === null || _f === void 0 ? void 0 : _f.call(_e);
+            }
+        }
+        catch (_g) { }
     }
     get isClosed() {
         return this.closed;

package/lib/telemetry/langfuse.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.langfuse = void 0;
+const langfuse_1 = require("langfuse");
+const secretKey = process.env.LANGFUSE_SECRET_KEY;
+const publicKey = process.env.LANGFUSE_PUBLIC_KEY;
+const baseUrl = process.env.LANGFUSE_BASEURL;
+exports.langfuse = new langfuse_1.Langfuse({
+    secretKey: "sk-lf-f389bb1e-24db-4b42-b506-8d6118f45044",
+    publicKey: "pk-lf-ee301553-7a64-4f0f-bf6b-a2ac1e5ca2df",
+    baseUrl: "https://xray-langfuse.devops.xiaohongshu.com",
+});
+exports.default = exports.langfuse;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vectorx/functions-framework",
-  "version": "0.1.3",
+  "version": "0.3.0",
   "description": "VectorX Functions Framework",
   "main": "lib/index.js",
   "types": "types/index.d.ts",
@@ -25,17 +25,18 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@vectorx/ai-types": "0.1.3",
-    "commander": "^12.1.0",
-    "nodemon": "^3.1.10",
+    "@vectorx/ai-types": "0.3.0",
     "async_hooks": "^1.0.0",
     "chalk": "4",
+    "commander": "^12.1.0",
     "dotenv": "^16.5.0",
     "koa": "^2.14.2",
     "koa-body": "^6.0.1",
     "koa-bodyparser": "^4.4.1",
     "koa-router": "^12.0.1",
+    "langfuse": "^3.38.4",
     "node-fetch": "v2",
+    "nodemon": "^3.1.10",
     "openai": "^4.103.0",
     "radix3": "^1.1.2",
     "raw-body": "^2.5.2",

package/types/framework.d.ts

@@ -15,6 +15,9 @@ export interface FrameworkOptions {
         agentRuntimeVersion: string;
         functionsFrameworkVersion: string;
     };
+    redLangfuseConfig?: {
+        enable?: boolean;
+    };
 }
 export type FunctionName = string;
 declare class AgentServerFramework {

package/types/logger.d.ts

@@ -55,6 +55,18 @@ declare class FunctionsLogger {
     logUserCodelog(): void;
     log(type: LogType, level: LogLevel, message: string, metadata?: any): void;
     getLogs(type: LogType, limit?: number): Promise<LogEntry[]>;
+    getLogsPaginated(options: {
+        type: LogType;
+        pageNum?: number;
+        pageSize?: number;
+    }): Promise<{
+        logs: LogEntry[];
+        pageNum: number;
+        pageSize: number;
+        total: number;
+        hasMore: boolean;
+    }>;
+    private getAllLogs;
     private createWinstonLogger;
     logError(error: Error | string, metadata?: any): void;
 }

package/types/server.d.ts

@@ -7,6 +7,7 @@ import type { Router } from "./router";
 declare module "koa" {
     interface DefaultState {
         isTimeout?: boolean;
+        langfuseTrace?: any;
     }
     interface Application {
         routers: Map<string, Router>;

package/types/telemetry/langfuse.d.ts

@@ -0,0 +1,4 @@
+import { Langfuse } from "langfuse";
+export declare const langfuse: Langfuse;
+export type LangfuseClient = typeof langfuse;
+export default langfuse;