@m6d/cortex-server 1.7.0 → 2.0.0

package/src/ai/interceptors/request-interceptor.ts

@@ -1,61 +0,0 @@
-import type { DatabaseAdapter } from "../../adapters/database.ts";
-import type { StorageAdapter } from "../../adapters/storage.ts";
-import { streamToBase64, tokenToUserId } from "../helpers.ts";
-
-export type ResolvedFile = {
-    name: string;
-    bytes: string;
-};
-
-export type RequestInterceptorOptions = {
-    transformFile?: (file: ResolvedFile) => unknown;
-};
-
-export function createRequestInterceptor(
-    db: DatabaseAdapter,
-    storage: StorageAdapter,
-    options?: RequestInterceptorOptions,
-) {
-    const transformFile = options?.transformFile ?? ((file: ResolvedFile) => file);
-
-    return async function resolveRequestBody(
-        body: Record<string, unknown>,
-        context: { token: string },
-    ) {
-        const userId = tokenToUserId(context.token);
-
-        async function traverse(obj: Record<string, unknown>) {
-            await Promise.all(
-                Object.keys(obj).map(async (key) => {
-                    const value = obj[key];
-                    if (typeof value === "string" && value.startsWith("capturedFile")) {
-                        const [_, uploadId] = value.split("#");
-                        const file = await db.capturedFiles.getById(uploadId!, userId);
-                        if (file) {
-                            const fileStream = await storage.stream(`captured_files/${uploadId}`);
-                            const bytes = await streamToBase64(fileStream);
-                            obj[key] = transformFile({ name: file.name, bytes });
-                        }
-                    }
-
-                    if (Array.isArray(value)) {
-                        await Promise.all(
-                            value.map(async (child) => {
-                                if (typeof child === "object" && child !== null) {
-                                    await traverse(child as Record<string, unknown>);
-                                }
-                            }),
-                        );
-                    }
-
-                    if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-                        await traverse(value as Record<string, unknown>);
-                    }
-                }),
-            );
-        }
-
-        await traverse(body);
-        return body;
-    };
-}

package/src/ai/prompt.ts

@@ -1,126 +0,0 @@
-import type { ResolvedContext } from "../graph/resolver.ts";
-import type { PromptContext, ResolvedCortexAgentConfig } from "../config.ts";
-import type { Thread } from "../types.ts";
-
-/**
- * Resolves session data for the thread, loading from the configured
- * session loader if not already cached on the thread.
- */
-export async function resolveSession(
-    config: ResolvedCortexAgentConfig,
-    thread: Thread,
-    token: string,
-) {
-    let session = thread.session;
-
-    if (!session && config.loadSessionData) {
-        session = await config.loadSessionData(token);
-        // Persist to DB for future cache hits
-        await config.db.threads.updateSession(thread.id, session);
-        thread.session = session;
-    }
-
-    return session;
-}
-
-export async function buildSystemPrompt(
-    config: ResolvedCortexAgentConfig,
-    resolved: ResolvedContext | null,
-    promptContext: PromptContext,
-) {
-    // Resolve the consumer's base system prompt
-    let basePrompt: string;
-    if (typeof config.systemPrompt === "function") {
-        basePrompt = await config.systemPrompt(promptContext);
-    } else {
-        basePrompt = config.systemPrompt;
-    }
-
-    const sections: string[] = [basePrompt];
-
-    // Pre-resolved endpoints from knowledge graph
-    if (resolved) {
-        sections.push(buildResolvedSection(resolved));
-    }
-
-    return sections.join("\n");
-}
-
-function buildResolvedSection(resolved: ResolvedContext) {
-    const parts: string[] = [
-        `
-## Pre-resolved API Endpoints
-The following endpoints were automatically matched to the user's message.`,
-    ];
-
-    for (const ep of resolved.readEndpoints) {
-        const rules = ep.rules.length > 0 ? `\n  Rules: ${ep.rules.join("; ")}` : "";
-        const deps =
-            ep.dependencies.length > 0
-                ? "\n  Dependencies:\n" +
-                  ep.dependencies
-                      .map(
-                          (d) =>
-                              `    - Call ${d.depMethod} ${d.depPath} first → use its "${d.fromField}" as "${d.paramName}"`,
-                      )
-                      .join("\n")
-                : "";
-        const meta = ep.metadata !== "{}" ? `\n- Metadata: ${ep.metadata}` : "";
-        parts.push(
-            `
-### ${ep.concept} (read)
-- Endpoint: ${ep.name}
-- ${ep.method} ${ep.path}
-- Params: ${ep.params}
-- Body: ${ep.body}
-- Response: ${ep.response}${rules}${deps}${meta}`,
-        );
-    }
-
-    for (const ep of resolved.writeEndpoints) {
-        const rules = ep.rules.length > 0 ? `\n  Rules: ${ep.rules.join("; ")}` : "";
-        const deps =
-            ep.dependencies.length > 0
-                ? "\n  Dependencies:\n" +
-                  ep.dependencies
-                      .map(
-                          (d) =>
-                              `    - Call ${d.depMethod} ${d.depPath} first → use its "${d.fromField}" as "${d.paramName}"`,
-                      )
-                      .join("\n")
-                : "";
-        const meta = ep.metadata !== "{}" ? `\n- Metadata: ${ep.metadata}` : "";
-        parts.push(
-            `
-### ${ep.concept} (write)
-- Endpoint: ${ep.name}
-- ${ep.method} ${ep.path}
-- Params: ${ep.params}
-- Body: ${ep.body}
-- Response: ${ep.response}${rules}${deps}${meta}`,
-        );
-    }
-
-    for (const svc of resolved.services) {
-        const rules = svc.rules.length > 0 ? `\n  Rules: ${svc.rules.join("; ")}` : "";
-        const meta = svc.metadata !== "{}" ? `\n- Metadata: ${svc.metadata}` : "";
-        parts.push(
-            `
-### ${svc.concept} via ${svc.serviceName} (service)
-- Built-in ID: ${svc.builtInId}
-- Description: ${svc.description || "N/A"}${rules}${meta}`,
-        );
-    }
-
-    if (
-        resolved.readEndpoints.length === 0 &&
-        resolved.writeEndpoints.length === 0 &&
-        resolved.services.length === 0
-    ) {
-        parts.push(
-            "\nNo matching endpoints found. Use queryGraph to search the knowledge graph manually.",
-        );
-    }
-
-    return parts.join("");
-}

package/src/ai/tools/call-endpoint.tool.ts

@@ -1,89 +0,0 @@
-import { tool } from "ai";
-import z from "zod";
-import type { ResolvedCortexAgentConfig } from "../../config.ts";
-import { fetchBackend } from "../fetch.ts";
-
-export function createCallEndpointTool(
-    backendFetch: NonNullable<ResolvedCortexAgentConfig["backendFetch"]>,
-    token: string,
-) {
-    return tool({
-        title: "Call an API endpoint",
-        description:
-            "Call an API endpoint on the backend. Use queryGraph first to discover the correct endpoint, parameters, and business rules. For write operations (POST/PUT/DELETE), ALWAYS get explicit user confirmation before calling.",
-        inputSchema: z.object({
-            path: z
-                .string()
-                .describe(
-                    'The API path including path parameters. Example: "/items/list" or "/resources/{id}"',
-                ),
-            method: z.enum(["GET", "POST", "PUT", "DELETE"]).describe("The HTTP method"),
-            queryParams: z
-                .string()
-                .optional()
-                .describe("Optional JSON-encoded string of query parameters."),
-            body: z
-                .string()
-                .optional()
-                .describe(
-                    "Optional JSON-encoded string of request body for POST/PUT. For parameters of type file, use `capturedFile#[uploadId]` as the value.",
-                ),
-        }),
-        execute: async ({ path, method, queryParams, body }) => {
-            let fullPath = path;
-            if (queryParams) {
-                const params = JSON.parse(queryParams) as Record<string, unknown>;
-                const searchParams = new URLSearchParams();
-                for (const [key, value] of Object.entries(params)) {
-                    if (value == null || value === "") continue;
-                    if (Array.isArray(value)) {
-                        for (const item of value) {
-                            searchParams.append(key, String(item));
-                        }
-                    } else {
-                        searchParams.set(key, String(value));
-                    }
-                }
-                const qs = searchParams.toString();
-                if (qs) fullPath += `?${qs}`;
-            }
-
-            const options: RequestInit = { method };
-            if (body && (method === "POST" || method === "PUT")) {
-                options.body = body;
-            }
-
-            const response = await fetchBackend(fullPath, backendFetch, token, options);
-
-            if (!response.ok) {
-                let message: string;
-                let details: unknown = undefined;
-                try {
-                    const errorBody = (await response.json()) as Record<string, unknown>;
-                    message =
-                        (errorBody.message as string) ||
-                        (errorBody.title as string) ||
-                        JSON.stringify(errorBody);
-                    if (errorBody.errors) {
-                        details = errorBody.errors;
-                    }
-                } catch {
-                    message = `Request failed with status ${response.status}`;
-                }
-                return JSON.stringify({
-                    error: true,
-                    status: response.status,
-                    message,
-                    ...(details ? { details } : {}),
-                });
-            }
-
-            if (response.status === 204) {
-                return JSON.stringify({ success: true });
-            }
-
-            const data = await response.json();
-            return JSON.stringify(data);
-        },
-    });
-}

package/src/ai/tools/capture-files.tool.ts

@@ -1,20 +0,0 @@
-import { tool } from "ai";
-import z from "zod";
-
-export const captureFilesTool = tool({
-    description: "Let the user upload a file",
-    inputSchema: z.object({
-        files: z.array(
-            z.object({
-                label: z
-                    .string()
-                    .describe("A label to view to the user to know what file they need to upload"),
-                id: z
-                    .string()
-                    .describe(
-                        "An ID to the file for you to use it when calling apis or later processing",
-                    ),
-            }),
-        ),
-    }),
-});

package/src/ai/tools/execute-code.tool.ts

@@ -1,153 +0,0 @@
-import { tool } from "ai";
-import z from "zod";
-import type { ResolvedCortexAgentConfig } from "../../config.ts";
-import { fetchBackend } from "../fetch.ts";
-import { getQuickJS, Scope, shouldInterruptAfterDeadline } from "quickjs-emscripten";
-
-function buildQueryString(params: Record<string, unknown>) {
-    const searchParams = new URLSearchParams();
-    for (const [key, value] of Object.entries(params)) {
-        if (value == null || value === "") continue;
-        if (Array.isArray(value)) {
-            for (const item of value) {
-                searchParams.append(key, String(item));
-            }
-        } else {
-            searchParams.set(key, String(value));
-        }
-    }
-    const qs = searchParams.toString();
-    return qs ? `?${qs}` : "";
-}
-
-async function runInSandbox(
-    code: string,
-    backendFetch: NonNullable<ResolvedCortexAgentConfig["backendFetch"]>,
-    token: string,
-) {
-    async function request(method: string, path: string, body?: unknown) {
-        const options: RequestInit = { method };
-        if (body !== undefined && (method === "POST" || method === "PUT")) {
-            options.body = JSON.stringify(body);
-        }
-
-        const response = await fetchBackend(path, backendFetch, token, options);
-
-        if (!response.ok) {
-            let message: string;
-            try {
-                const errorBody = await response.json();
-                message = JSON.stringify(errorBody);
-            } catch {
-                message = `HTTP ${response.status}`;
-            }
-            throw new Error(`API ${method} ${path} failed (${response.status}): ${message}`);
-        }
-
-        if (response.status === 204) return { success: true };
-        return response.json();
-    }
-
-    return await Scope.withScopeAsync(async (scope) => {
-        const QuickJS = await getQuickJS();
-
-        const runtime = scope.manage(QuickJS.newRuntime());
-        runtime.setMemoryLimit(1024 * 1024 * 20); // 20MB
-        runtime.setInterruptHandler(shouldInterruptAfterDeadline(Date.now() + 10_000)); // 60 seconds;
-
-        const vm = scope.manage(runtime.newContext());
-
-        function drainJobs() {
-            vm.runtime.executePendingJobs();
-        }
-
-        function makeApiFunction(fn: (...args: unknown[]) => Promise<unknown>) {
-            return scope.manage(
-                vm.newFunction(fn.name, (...argHandles) => {
-                    const args = argHandles.map(vm.dump.bind(vm));
-                    const promise = scope.manage(
-                        vm.newPromise(
-                            fn(...args).then((result) =>
-                                scope.manage(
-                                    vm.unwrapResult(vm.evalCode(`(${JSON.stringify(result)})`)),
-                                ),
-                            ),
-                        ),
-                    );
-
-                    promise.settled.finally(() => {
-                        drainJobs();
-                    });
-
-                    return promise.handle;
-                }),
-            );
-        }
-
-        const apiHandle = scope.manage(vm.newObject());
-        vm.setProp(
-            apiHandle,
-            "get",
-            makeApiFunction(async (path, queryParams?) => {
-                const fullPath = queryParams
-                    ? path + buildQueryString(queryParams as Record<string, unknown>)
-                    : path;
-                return await request("GET", fullPath as string);
-            }),
-        );
-        vm.setProp(
-            apiHandle,
-            "post",
-            makeApiFunction(async (path, body) => await request("POST", path as string, body)),
-        );
-        vm.setProp(
-            apiHandle,
-            "put",
-            makeApiFunction(async (path, body) => await request("PUT", path as string, body)),
-        );
-        vm.setProp(
-            apiHandle,
-            "del",
-            makeApiFunction(async (path) => await request("DELETE", path as string)),
-        );
-
-        vm.setProp(vm.global, "api", apiHandle);
-
-        const runResult = vm.evalCode(`(async () => {
-                ${code}
-            })()`);
-        const resultHandle = scope.manage(vm.unwrapResult(runResult));
-        const pending = vm.resolvePromise(resultHandle);
-        drainJobs();
-        const resolvedResult = await pending;
-        const result = scope.manage(vm.unwrapResult(resolvedResult));
-        return vm.dump(result);
-    });
-}
-
-export function createExecuteCodeTool(
-    backendFetch: NonNullable<ResolvedCortexAgentConfig["backendFetch"]>,
-    token: string,
-) {
-    return tool({
-        title: "Executes JavaScript code",
-        description:
-            "Run a JavaScript script that calls APIs and returns only relevant data. The script has an `api` helper: api.get(path, params?), api.post(path, body?), api.put(path, body?), api.del(path). Each returns parsed JSON and throws on error. For parameters of type file, use `capturedFile#[uploadId]` as the value.",
-        inputSchema: z.object({
-            code: z
-                .string()
-                .describe(
-                    "Async JS function body. Use the `api` helper to call endpoints. Return only the data needed for your response.",
-                ),
-        }),
-        execute: async ({ code }) => {
-            try {
-                const result = await runInSandbox(code, backendFetch, token);
-                return JSON.stringify(result);
-            } catch (e) {
-                const message = e instanceof Error ? e.message : String(e);
-                return JSON.stringify({ error: true, message });
-            }
-        },
-    });
-}