@vectorx/functions-framework 0.0.0-beta-20251112071234

package/lib/utils/helper.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepFreeze = deepFreeze;
+exports.isPlainObject = isPlainObject;
+exports.isFormData = isFormData;
+exports.toQueryString = toQueryString;
+exports.obj2StrRecord = obj2StrRecord;
+exports.formatUrl = formatUrl;
+exports.getDependencyVersion = getDependencyVersion;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function deepFreeze(obj) {
+    if (obj === null || typeof obj !== "object") {
+        return obj;
+    }
+    Object.keys(obj).forEach((prop) => {
+        const value = obj[prop];
+        if (typeof value === "object" && value !== null) {
+            deepFreeze(value);
+        }
+    });
+    return Object.freeze(obj);
+}
+function isPlainObject(obj) {
+    if (obj === null || typeof obj !== "object") {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(obj);
+    return proto === Object.prototype || proto === null;
+}
+function isFormData(val) {
+    return Object.prototype.toString.call(val) === "[object FormData]";
+}
+function toQueryString(data) {
+    return Object.entries(data)
+        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`)
+        .join("&");
+}
+function obj2StrRecord(obj) {
+    return Object.entries(obj).reduce((acc, cur) => {
+        const [key, value] = cur;
+        acc[key] = String(value);
+        return acc;
+    }, {});
+}
+function formatUrl(PROTOCOL, url, query) {
+    if (query === void 0) {
+        query = {};
+    }
+    var urlHasQuery = /\?/.test(url);
+    var queryString = "";
+    Object.keys(query).forEach((key) => {
+        if (queryString === "") {
+            !urlHasQuery && (url += "?");
+        }
+        else {
+            queryString += "&";
+        }
+        queryString += "".concat(key, "=").concat(encodeURIComponent(query[key]));
+    });
+    url += queryString;
+    if (/^http(s)?:\/\//.test(url)) {
+        return url;
+    }
+    return "".concat(PROTOCOL).concat(url);
+}
+function getDependencyVersion(packageName, searchPath) {
+    try {
+        const packagePath = require.resolve(packageName, { paths: [searchPath] });
+        let currentPath = path_1.default.dirname(packagePath);
+        let packageJsonPath = path_1.default.join(currentPath, "package.json");
+        while (!fs_1.default.existsSync(packageJsonPath) && currentPath !== path_1.default.parse(currentPath).root) {
+            currentPath = path_1.default.dirname(currentPath);
+            packageJsonPath = path_1.default.join(currentPath, "package.json");
+        }
+        if (fs_1.default.existsSync(packageJsonPath)) {
+            const pkg = require(packageJsonPath);
+            return pkg.version || null;
+        }
+        return null;
+    }
+    catch (e) {
+        return null;
+    }
+}

package/lib/utils/machineId.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.machineIdSync = machineIdSync;
+exports.machineId = machineId;
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const { platform } = process, win32RegBinPath = {
+    native: "%windir%\\System32",
+    mixed: "%windir%\\sysnative\\cmd.exe /c %windir%\\System32",
+}, guid = {
+    darwin: "ioreg -rd1 -c IOPlatformExpertDevice",
+    win32: `${win32RegBinPath[isWindowsProcessMixedOrNativeArchitecture()]}\\REG.exe ` +
+        "QUERY HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography " +
+        "/v MachineGuid",
+    linux: "( cat /var/lib/dbus/machine-id /etc/machine-id 2> /dev/null || hostname ) | head -n 1 || :",
+    freebsd: "kenv -q smbios.system.uuid || sysctl -n kern.hostuuid",
+};
+function isWindowsProcessMixedOrNativeArchitecture() {
+    if (process.platform !== "win32") {
+        return "";
+    }
+    if (process.arch === "ia32" && process.env.hasOwnProperty("PROCESSOR_ARCHITEW6432")) {
+        return "mixed";
+    }
+    return "native";
+}
+function hash(guid) {
+    return (0, crypto_1.createHash)("sha256").update(guid).digest("hex");
+}
+function expose(result) {
+    switch (platform) {
+        case "darwin":
+            return result
+                .split("IOPlatformUUID")[1]
+                .split("\n")[0]
+                .replace(/\=|\s+|\"/gi, "")
+                .toLowerCase();
+        case "win32":
+            return result
+                .toString()
+                .split("REG_SZ")[1]
+                .replace(/\r+|\n+|\s+/gi, "")
+                .toLowerCase();
+        case "linux":
+            return result
+                .toString()
+                .replace(/\r+|\n+|\s+/gi, "")
+                .toLowerCase();
+        case "freebsd":
+            return result
+                .toString()
+                .replace(/\r+|\n+|\s+/gi, "")
+                .toLowerCase();
+        default:
+            throw new Error(`Unsupported platform: ${process.platform}`);
+    }
+}
+function machineIdSync(original) {
+    const id = expose((0, child_process_1.execSync)(guid[platform]).toString());
+    return original ? id : hash(id);
+}
+function machineId(original) {
+    return new Promise((resolve, reject) => {
+        return (0, child_process_1.exec)(guid[platform], {}, (err, stdout, stderr) => {
+            if (err) {
+                return reject(new Error(`Error while obtaining machine id: ${err.stack}`));
+            }
+            const id = expose(stdout.toString());
+            return resolve(original ? id : hash(id));
+        });
+    });
+}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@vectorx/functions-framework",
+  "version": "0.0.0-beta-20251112071234",
+  "description": "VectorX Functions Framework",
+  "main": "lib/index.js",
+  "types": "types/index.d.ts",
+  "bin": {
+    "rcb-ff": "./bin/rcb-ff.js"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "types",
+    "README.md"
+  ],
+  "keywords": [
+    "cloud-functions",
+    "koa",
+    "serverless",
+    "nodejs"
+  ],
+  "author": "",
+  "license": "ISC",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@vectorx/ai-types": "0.0.0-beta-20251112071234",
+    "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",
+    "uuid": "^9.0.1",
+    "winston": "^3.11.0",
+    "winston-daily-rotate-file": "^4.7.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/koa": "^2.13.12",
+    "@types/koa-bodyparser": "^4.3.12",
+    "@types/koa-router": "^7.4.8",
+    "@types/node": "^20.11.24",
+    "@types/supertest": "^6.0.2",
+    "@types/uuid": "^9.0.8",
+    "@typescript-eslint/eslint-plugin": "^7.1.0",
+    "@typescript-eslint/parser": "^7.1.0",
+    "eslint": "^8.57.0",
+    "jest": "^29.7.0",
+    "rimraf": "^3.0.2",
+    "supertest": "^6.3.4",
+    "ts-jest": "^29.1.2",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.3.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:ci": "jest --ci --coverage",
+    "lint": "eslint src --ext .ts",
+    "run:demo": "node ./bin/rcb-ff.js"
+  },
+  "readme": "# VectorX Functions Framework\n\nVectorX Functions Framework 是一个用于构建和运行云函数的框架，提供了完整的日志系统支持。\n\n## 日志系统\n\n框架内置了完整的日志系统，支持请求日志记录和用户代码日志记录。\n\n### 配置\n\n在初始化框架时，可以配置日志系统：\n\n```typescript\nimport { createAgentServerFramework } from '@vectorx/functions-framework';\n\nconst framework = createAgentServerFramework({\n    port: 3000,\n    logging: {\n        dirname: '/path/to/logs',  // 日志存储目录\n        maxSize: '20m',           // 单个日志文件最大大小\n        maxFiles: 14              // 保留的日志文件数量\n    }\n});\n```\n\n### 日志类型\n\n框架支持两种类型的日志：\n\n- `ACCESS`: 访问日志，记录所有 HTTP 请求\n- `USERCODE`: 用户代码日志，记录用户函数中的日志\n\n### 日志查询 API\n\n框架提供了日志查询 API，用于查看和调试日志：\n\n```\nGET /@logs\n```\n\n#### 查询参数\n\n| 参数名 | 类型 | 必填 | 说明 |\n|--------|------|------|------|\n| type | string | 否 | 日志类型，可选值：ACCESS/USERCODE，默认 ACCESS |\n| limit | number | 否 | 返回的日志条数限制，默认 100 |\n| eventId | string | 否 | 按 eventId 过滤日志 |\n\n#### 示例\n\n1. 查询所有访问日志：\n```bash\ncurl 'http://localhost:3000/@logs?type=ACCESS'\n```\n\n2. 查询特定 eventId 的日志：\n```bash\ncurl 'http://localhost:3000/@logs?eventId=550e8400-e29b-41d4-a716-446655440000'\n```\n\n3. 限制返回条数：\n```bash\ncurl 'http://localhost:3000/@logs?limit=10'\n```\n\n4. 组合查询：\n```bash\ncurl 'http://localhost:3000/@logs?type=USERCODE&eventId=550e8400-e29b-41d4-a716-446655440000&limit=20'\n```\n\n#### 响应格式\n\n成功响应：\n```json\n{\n    \"success\": true,\n    \"data\": [\n        {\n            \"@timestamp\": \"2024-03-21T10:30:00.000Z\",\n            \"level\": \"info\",\n            \"eventId\": \"550e8400-e29b-41d4-a716-446655440000\",\n            \"message\": \"Request started\",\n            \"method\": \"GET\",\n            \"url\": \"/api/example\"\n        }\n    ]\n}\n```\n\n错误响应：\n```json\n{\n    \"success\": false,\n    \"error\": \"错误信息\"\n}\n```\n\n### 在代码中使用日志\n\n```typescript\nimport { functionsLogger } from '@vectorx/functions-framework';\nimport { LogLevel } from '@vectorx/functions-framework';\n\n// 记录访问日志\nfunctionsLogger.logAccesslog(LogLevel.INFO, 'Custom message', {\n    customField: 'value'\n});\n\n// 记录用户代码日志\nfunctionsLogger.logUserCodelog([\n    { message: 'User log message', level: 'info' }\n]);\n```\n\n### 日志格式\n\n每条日志都包含以下字段：\n\n- `@timestamp`: 日志时间戳\n- `level`: 日志级别\n- `eventId`: 请求 ID\n- `message`: 日志消息\n- 其他自定义字段\n\n## 开发\n\n### 运行测试\n\n```bash\nnpm test\n```\n\n### 构建\n\n```bash\nnpm run build\n``` \n\n\n### 环境管理\n读取 .env 文件，校验 env 文件的可用性，获取当前运行环境\n"
+}

package/types/async-context.d.ts

@@ -0,0 +1,17 @@
+import type { IUserCodeLogItem } from "./logger";
+declare const CONTEXT_ID: unique symbol;
+export interface ExecutionContext {
+    id: typeof CONTEXT_ID;
+    done: boolean;
+    eventID: string;
+    userCodeLogs?: Array<IUserCodeLogItem>;
+    userCodeLogsFlushTimer?: NodeJS.Timeout;
+    apmMeasurementData?: Record<string, any>;
+}
+export declare function newExecutionContext(eventId: string, apmData?: Record<string, any>): ExecutionContext;
+export declare function getCurrentEventID(): string;
+export declare function getCurrentAsyncContext(): ExecutionContext | undefined;
+export declare function isInFrameworkAsyncContext(): boolean;
+export declare function done(): Promise<void>;
+export declare function wrapWithAsyncContext<T>(executionContext: ExecutionContext, fn: () => Promise<T>): Promise<T>;
+export {};

package/types/config.d.ts

@@ -0,0 +1 @@
+export declare function getBaseUrl(): string;

package/types/constants.d.ts

@@ -0,0 +1,2 @@
+import type { FrameworkOptions } from "./framework";
+export declare const defaultOptions: FrameworkOptions;

package/types/error.d.ts

@@ -0,0 +1,20 @@
+export declare class AppError extends Error {
+    code: number;
+    cause: any;
+    constructor(code: number, message: string, options: {
+        cause: Error | string;
+    });
+}
+export declare enum ErrorCode {
+    SYS_ERR = 500,
+    BAD_REQUEST = 400,
+    TIMEOUT = 408,
+    TOO_MANY_REQUESTS = 429,
+    UNAUTHORIZED = 401
+}
+export declare function decorateErrorStack(err: any): any;
+export declare function newSysErr(err: Error | string): AppError;
+export declare function newBadRequestErr(err: Error | string): AppError;
+export declare function newTimeoutErr(): AppError;
+export declare function newTooManyRequestsErr(err: Error | string): AppError;
+export declare function newUnauthorizedErr(err: Error | string): AppError;

package/types/framework.d.ts

@@ -0,0 +1,32 @@
+declare function getDependencyVersion(packageName: string, searchPath: string): string | null;
+export interface FrameworkOptions {
+    port: number;
+    timeoutMS: number;
+    keepAliveTimeoutMS: number;
+    functionsConfigFile: string;
+    enableCors: boolean;
+    allowedOrigins?: string[];
+    logging?: {
+        dirname?: string;
+        maxSize?: string;
+        maxFiles?: number;
+    };
+    kitInfo?: {
+        agentRuntimeVersion: string;
+        functionsFrameworkVersion: string;
+    };
+    redLangfuseConfig?: {
+        enable?: boolean;
+    };
+}
+export type FunctionName = string;
+declare class AgentServerFramework {
+    private options;
+    private router;
+    private apmReporter;
+    constructor(options: FrameworkOptions);
+    startServer(): Promise<import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>>;
+    getRegisteredFunction(fnName: string): Function;
+}
+export { getDependencyVersion };
+export declare function createAgentServerFramework(options: FrameworkOptions): AgentServerFramework;

package/types/function-loader.d.ts

@@ -0,0 +1,26 @@
+export declare const DEFAULT_FN_NAME = "main";
+export interface FunctionConfig {
+    name: string;
+    directory: string;
+    source: string;
+    triggerPath: string;
+}
+export interface RouteConfig {
+    functionName: string;
+    path: string;
+}
+export interface CloudFunctionConfig {
+    agentId: string;
+    functionsRoot: string;
+    functions?: FunctionConfig[];
+    routes?: RouteConfig[];
+}
+export interface ProjectConfig {
+    agentId: string;
+    version: string;
+    desc: string;
+    "@vectorx/agent-runtime": string;
+    "@vectorx/functions-framework": string;
+}
+export declare function loadFunctionsConfig(configPath: string): CloudFunctionConfig;
+export declare function loadFunction(functionsRoot: string, functionConfig: FunctionConfig): any;

package/types/function-registry.d.ts

@@ -0,0 +1,4 @@
+export declare function buildFnId(fnName: string, functionName: string): string;
+export declare function registerFunction(fnName: string, fn: Function): void;
+export declare function getRegisteredFunction(fnId: string): Function | undefined;
+export declare function clearRegistry(): void;

package/types/function-wrapper.d.ts

@@ -0,0 +1,3 @@
+import type { Context, Next } from "koa";
+import type { ProjectConfig } from "./function-loader";
+export declare function wrapHandlerFunction(userFunction: Function, projectConfig: ProjectConfig): (ctx: Context, next: Next) => Promise<void>;

package/types/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./framework";
+export * from "./router";
+export * from "./function-loader";
+export * from "./function-registry";
+export * from "./sse";
+export * from "./server";
+export * from "./logger";

package/types/logger.d.ts

@@ -0,0 +1,74 @@
+import type { ApmReporter } from "./utils/apm";
+export declare enum LogType {
+    ACCESS = "ACCESS",
+    USERCODE = "USERCODE"
+}
+export interface ILog {
+    "@timestamp": string;
+    logType: LogType;
+}
+export interface IUserCodeLogItem {
+    "@timestamp"?: string;
+    caller?: string;
+    stacktraces?: string;
+    level?: string;
+    content: string | Uint8Array;
+}
+export interface IUserCodeLog {
+    "@timestamp": string;
+    logType: LogType;
+    level: "log" | "info" | "warn" | "error";
+    module: string;
+    name: string;
+    eventId: string;
+    requestId: string;
+    scene?: "logBeforeReturn" | "logAfterReturn";
+    logs: IUserCodeLogItem[];
+}
+export declare enum LogLevel {
+    ERROR = "error",
+    WARN = "warn",
+    INFO = "info",
+    DEBUG = "debug"
+}
+export interface LogEntry {
+    message: string;
+    level: string;
+    [key: string]: any;
+}
+export interface LoggerConfig {
+    type: LogType;
+    options: {
+        dirname?: string;
+        maxSize?: string;
+        maxFiles?: number;
+    };
+}
+declare class FunctionsLogger {
+    private tLoggers;
+    private apmReporter?;
+    constructor();
+    setApmReporter(reporter: ApmReporter): void;
+    init(opts: LoggerConfig[]): void;
+    private formatLogMessage;
+    logAccesslog(level: LogLevel, message: string, metadata?: any): void;
+    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;
+}
+export declare const functionsLogger: FunctionsLogger;
+export {};

package/types/middlewares/index.d.ts

@@ -0,0 +1,8 @@
+export { asyncContextMiddleware } from "./middle-async-context";
+export { contextInjectionMiddleware } from "./middle-context-injection";
+export { eventIdMiddleware } from "./middle-event-id";
+export { functionRouteMiddleware } from "./middle-function-route";
+export { loggerMiddleware } from "./middle-common-logger";
+export { logsQueryMiddleware } from "./middle-logs-request";
+export { openGwRequestMiddleware } from "./middle-open-gw-request";
+export { apmMiddleware } from "./middle-apm-injection";

package/types/middlewares/middle-apm-injection.d.ts

@@ -0,0 +1,2 @@
+import type { Context, Next } from "koa";
+export declare function apmMiddleware(): (ctx: Context, next: Next) => Promise<any>;

package/types/middlewares/middle-async-context.d.ts

@@ -0,0 +1,2 @@
+declare const asyncContextMiddleware: () => (ctx: any, next: any) => Promise<void>;
+export { asyncContextMiddleware };

package/types/middlewares/middle-common-logger.d.ts

@@ -0,0 +1,2 @@
+import type { Context, Next } from "koa";
+export declare function loggerMiddleware(): (ctx: Context, next: Next) => Promise<void>;

package/types/middlewares/middle-context-injection.d.ts

@@ -0,0 +1,4 @@
+import type { Context, Next } from "koa";
+import type { FrameworkOptions } from "../framework";
+import type { ProjectConfig } from "../function-loader";
+export declare function contextInjectionMiddleware(frameworkOptions: FrameworkOptions, projectConfig: ProjectConfig): (ctx: Context, next: Next) => Promise<void>;

package/types/middlewares/middle-event-id.d.ts

@@ -0,0 +1,2 @@
+declare const eventIdMiddleware: () => (ctx: any, next: any) => Promise<void>;
+export { eventIdMiddleware };

package/types/middlewares/middle-function-route.d.ts

@@ -0,0 +1,4 @@
+import type { Context, Next } from "koa";
+import type { ProjectConfig } from "../function-loader";
+import { type Router } from "../router";
+export declare function functionRouteMiddleware(router: Router, projectConfig: ProjectConfig): (ctx: Context, next: Next) => Promise<any>;

package/types/middlewares/middle-logs-request.d.ts

@@ -0,0 +1,3 @@
+import type { Context, Next } from "koa";
+declare function logsQueryMiddleware(): (ctx: Context, next: Next) => Promise<any>;
+export { logsQueryMiddleware };

package/types/middlewares/middle-open-gw-request.d.ts

@@ -0,0 +1,2 @@
+import type { Context, Next } from "koa";
+export declare function openGwRequestMiddleware(agentId: string): (ctx: Context, next: Next) => Promise<void>;

package/types/request.d.ts

@@ -0,0 +1,46 @@
+import type { IAbstractRequest } from "@vectorx/ai-types";
+export interface IRequestConfig {
+    timeout?: number;
+    timeoutMsg?: string;
+    restrictedMethods?: Array<IRequestMethod>;
+    defaultHeaders?: Record<string, string>;
+}
+export type IRequestMethod = "get" | "post" | "put" | "upload" | "download";
+export interface IRequestOptions {
+    url?: string;
+    headers?: Record<string, string>;
+    data?: any;
+    responseType?: string;
+    withCredentials?: boolean;
+    body?: any;
+    method?: string;
+    file?: File;
+    name?: string;
+}
+export interface IFetchOptions {
+    url: string;
+    headers?: HeadersInit;
+    body?: any;
+    method?: string;
+    enableAbort?: boolean;
+    stream?: boolean;
+}
+export interface ResponseObject<T = any> {
+    data?: T;
+    statusCode?: number;
+    [key: string]: any;
+}
+export declare class Request implements IAbstractRequest {
+    private readonly timeout;
+    private readonly timeoutMsg;
+    private readonly restrictedMethods;
+    private readonly defaultHeaders;
+    constructor(config?: IRequestConfig);
+    get<T = any>(options: IRequestOptions): Promise<ResponseObject<T>>;
+    post<T = any>(options: IRequestOptions): Promise<ResponseObject<T>>;
+    put<T = any>(options: IRequestOptions): Promise<ResponseObject<T>>;
+    upload<T = any>(options: IRequestOptions): Promise<ResponseObject<T>>;
+    download(options: IRequestOptions): Promise<unknown>;
+    protected request(options: IRequestOptions, enableAbort?: boolean): Promise<ResponseObject>;
+    fetch(options: IFetchOptions): Promise<ResponseObject>;
+}

package/types/router.d.ts

@@ -0,0 +1,15 @@
+import type { CloudFunctionConfig, RouteConfig } from "./function-loader";
+export declare class Router {
+    private routes;
+    private router;
+    constructor(config: CloudFunctionConfig);
+    private addRoute;
+    findRoute(path: string): RouteConfig | null;
+}
+export declare function routeFunction(router: Router | undefined, path: string): {
+    routeDefinition: RouteConfig;
+    handleFunction: Function;
+} | {
+    routeDefinition?: undefined;
+    handleFunction?: undefined;
+};

package/types/server.d.ts

@@ -0,0 +1,33 @@
+import http from "http";
+import type { FrameworkOptions } from "./framework";
+import type { ProjectConfig } from "./function-loader";
+import type { functionsLogger } from "./logger";
+import type { Request } from "./request";
+import type { Router } from "./router";
+declare module "koa" {
+    interface DefaultState {
+        isTimeout?: boolean;
+        langfuseTrace?: any;
+    }
+    interface Application {
+        routers: Map<string, Router>;
+    }
+    interface Context {
+        rawBody?: any;
+        extendedContext?: any;
+        httpContext?: any;
+        sse?: () => any;
+    }
+}
+export interface RcbContext {
+    ctxId: string;
+    eventID: string;
+    eventType: string;
+    timestamp: number;
+    httpContext: any;
+    request: Request;
+    logger: typeof functionsLogger;
+    baseUrl: string;
+    sse: () => any;
+}
+export declare function createServer(options: FrameworkOptions, router: Router, projectConfig: ProjectConfig): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;

package/types/sse.d.ts

@@ -0,0 +1,23 @@
+import { EventEmitter } from "events";
+import * as util from "util";
+import type { Context } from "koa";
+export interface SSEMessage {
+    id?: string;
+    event?: string;
+    data: any;
+    retry?: number;
+    comment?: string;
+}
+export declare class ServerSentEvent extends EventEmitter {
+    private ctx;
+    private stream;
+    private closed;
+    private encoder;
+    constructor(ctx: Context);
+    setEncoder(encoder: util.TextEncoder): void;
+    emitMessage(event: string, data: any): boolean;
+    emit(event: string | symbol, ...args: any[]): boolean;
+    send(event: SSEMessage | SSEMessage[] | string | Buffer): boolean;
+    end(msg?: SSEMessage | SSEMessage[] | string | Buffer): void;
+    get isClosed(): boolean;
+}

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;

package/types/types.d.ts

@@ -0,0 +1,18 @@
+export interface RcbContext {
+    httpContext?: {
+        url: string;
+    };
+    request: (options: {
+        method: string;
+        url: string;
+        headers?: Record<string, string>;
+        body?: string;
+        stream?: boolean;
+        timeout?: number;
+    }) => Promise<{
+        data: any;
+        header?: Headers;
+    }>;
+    getBaseUrl: () => string;
+    eventID: string;
+}

package/types/unified-responder.d.ts

@@ -0,0 +1,15 @@
+import type { Context } from "koa";
+import { type AppError } from "./error";
+export interface ResponseBody {
+    code: string;
+    message: string;
+    data?: any;
+    stack?: string;
+    requestId?: string;
+}
+export interface IntegrationResponse {
+    statusCode: number;
+    headers: Record<string, string>;
+    body: any;
+}
+export declare function sendResponse(ctx: Context, data?: any, error?: AppError, errStatusCode?: number, withStack?: boolean): void;

package/types/user-logger.d.ts

@@ -0,0 +1,5 @@
+declare function takeUserCodeLogs(): import("./logger").IUserCodeLogItem[];
+declare function pushUserCodeLogs(log: any): void;
+declare function addUserCodeLog(log: any): void;
+declare function getUserCodeLogs(): import("./logger").IUserCodeLogItem[];
+export { takeUserCodeLogs, pushUserCodeLogs, addUserCodeLog, getUserCodeLogs };