@m6d/cortex-server 1.7.0 → 1.8.0

package/src/sample/official-statements/types.ts

@@ -0,0 +1,23 @@
+export type OfficialStatementDeclarant = {
+    fullName: string;
+    address: string;
+    contactMethod: string;
+    contactNumber: string;
+};
+
+export type OfficialStatementQA = {
+    question: string;
+    answer: string;
+};
+
+export type OfficialStatementData = {
+    reference: string;
+    caseType: string;
+    dateOfRecord: string;
+    timeOfRecord: string;
+    declarant: OfficialStatementDeclarant;
+    investigation: OfficialStatementQA[];
+    declarantName: string;
+    officerName: string;
+    locked: boolean;
+};

package/dist/src/ai/context/compressor.d.ts

@@ -1,7 +0,0 @@
-import type { UIMessage } from "ai";
-import type { MessageMetadata } from "src/types.ts";
-/**
- * Returns a new array of messages with large tool outputs truncated
- * to `maxTokensPerResult`. Does not mutate the input messages.
- */
-export declare function compressToolResults(messages: UIMessage<MessageMetadata>[], maxTokensPerResult: number): UIMessage<MessageMetadata, import("ai").UIDataTypes, import("ai").UITools>[];

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

@@ -1,7 +0,0 @@
-import type { ResolvedCortexAgentConfig } from "../../config.ts";
-export declare function createCallEndpointTool(backendFetch: NonNullable<ResolvedCortexAgentConfig["backendFetch"]>, token: string): import("ai").Tool<{
-    method: "GET" | "POST" | "PUT" | "DELETE";
-    path: string;
-    body?: string | undefined;
-    queryParams?: string | undefined;
-}, string>;

package/src/ai/context/compressor.ts

@@ -1,47 +0,0 @@
-import type { UIMessage } from "ai";
-import { estimateTokens, CHARS_PER_TOKEN } from "./token-estimator.ts";
-import type { MessageMetadata } from "src/types.ts";
-
-/**
- * Returns a new array of messages with large tool outputs truncated
- * to `maxTokensPerResult`. Does not mutate the input messages.
- */
-export function compressToolResults(
-    messages: UIMessage<MessageMetadata>[],
-    maxTokensPerResult: number,
-) {
-    return messages.map((message) => {
-        let hasLargeToolOutput = false;
-
-        for (const part of message.parts) {
-            if ("toolCallId" in part && "output" in part && part.output != null) {
-                const outputTokens = estimateTokens(JSON.stringify(part.output));
-                if (outputTokens > maxTokensPerResult) {
-                    hasLargeToolOutput = true;
-                    break;
-                }
-            }
-        }
-
-        if (!hasLargeToolOutput) return message;
-
-        const compressedParts = message.parts.map((part) => {
-            if (!("toolCallId" in part) || !("output" in part) || part.output == null) {
-                return part;
-            }
-
-            const outputStr = JSON.stringify(part.output);
-            const outputTokens = estimateTokens(outputStr);
-
-            if (outputTokens <= maxTokensPerResult) return part;
-
-            // Convert token budget back to character budget
-            const charBudget = maxTokensPerResult * CHARS_PER_TOKEN;
-            const truncatedOutput = outputStr.slice(0, charBudget) + "\n[...truncated]";
-
-            return { ...part, output: truncatedOutput } as typeof part;
-        });
-
-        return { ...message, parts: compressedParts };
-    });
-}

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/db/migrations/20260315000000_add_context_meta/migration.sql

@@ -1 +0,0 @@
-ALTER TABLE [ai].[threads] ADD [context_meta] nvarchar(max);

package/dist/src/{graph → lib/graph}/helpers.d.ts

@@ -30,10 +30,10 @@ export declare function defineDomain(def: Omit<DomainDef, "__brand">): {
     name: string;
     description: string;
     metadata?: Record<string, unknown> | undefined;
+    rules?: RuleDef[] | undefined;
     concepts?: ConceptDef[] | undefined;
-    endpoints?: EndpointDef[] | undefined;
     services?: ServiceDef[] | undefined;
-    rules?: RuleDef[] | undefined;
+    endpoints?: EndpointDef[] | undefined;
     __brand: "domain";
 };
 export declare function defineEndpoint(input: EndpointInput): {