@m6d/cortex-server 1.6.0 → 1.8.0

package/dist/index.d.ts

@@ -1 +1 @@
-export * from "./src/index";
+export * from "./src/lib/index";

package/dist/src/{adapters → lib/adapters}/database.d.ts

@@ -1,5 +1,5 @@
 import type { ToolUIPart, UIMessage } from "ai";
-import type { Thread, StoredMessage, CapturedFileInput } from "../types";
+import type { Thread, StoredMessage, CapturedFileInput, TokenUsage } from "../types";
 import type { ThreadContextMeta } from "../ai/context/types.ts";
 export type DatabaseAdapter = {
     threads: {
@@ -18,6 +18,21 @@ export type DatabaseAdapter = {
         }): Promise<StoredMessage[]>;
         upsert(threadId: string, messages: UIMessage[]): Promise<void>;
     };
+    llmRequests: {
+        insert(requests: {
+            messageId: string;
+            stepNumber: number;
+            prompt: string;
+            output: string | null;
+            tokenUsage: TokenUsage | null;
+        }[]): Promise<void>;
+        listByMessageId(messageId: string): Promise<{
+            id: string;
+            prompt: string;
+            output: string | null;
+            tokenUsage: TokenUsage | null;
+        }[]>;
+    };
     capturedFiles: {
         create(userId: string, messageId: string, toolPart: ToolUIPart, files: CapturedFileInput[]): Promise<{
             id: string;

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

@@ -0,0 +1,18 @@
+import type { UIMessage } from "ai";
+import type { MessageMetadata } from "../../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>[];
+/**
+ * Structurally compresses a value to fit within a character budget.
+ * Understands JSON arrays, error objects, and nested objects — preserving
+ * semantic meaning better than naive string truncation.
+ */
+export declare function smartStructuralCompress(value: unknown, charBudget: number): string;
+/**
+ * Produces a short human-readable summary of a value's shape and key data.
+ * Used both for inline object-key placeholders and for tool result one-liners.
+ */
+export declare function summarizeValue(val: unknown): string;

package/dist/src/{ai → lib/ai}/context/index.d.ts

@@ -1,9 +1,10 @@
 export type { ContextConfig, ThreadContextMeta } from "./types.ts";
 export { DEFAULT_CONTEXT_CONFIG } from "./types.ts";
 export { CHARS_PER_TOKEN, estimateTokens, estimateMessageTokens, estimateMessagesTokens, } from "./token-estimator.ts";
-export { compressToolResults } from "./compressor.ts";
+export { compressToolResults, smartStructuralCompress, summarizeValue } from "./compressor.ts";
 export { summarizeMessages } from "./summarizer.ts";
 export { buildContextMessages, trimMessagesToFit } from "./builder.ts";
+export { compressIntraTurnToolResults, estimateToolResultTokens, summarizeOldStepResults, } from "./intra-turn-compressor.ts";
 import type { UIMessage } from "ai";
 import type { ResolvedCortexAgentConfig } from "../../config.ts";
 import type { Thread } from "../../types.ts";

package/dist/src/lib/ai/context/intra-turn-compressor.d.ts

@@ -0,0 +1,24 @@
+import type { LanguageModelV3Prompt } from "@ai-sdk/provider";
+import type { ContextConfig } from "./types.ts";
+type SummarizationModelConfig = NonNullable<ContextConfig["summarizationModel"]>;
+/**
+ * Compresses tool results from older steps in the prompt.
+ *
+ * On step N, tool results from steps 1..N-2 are aggressively compressed
+ * to short one-liners. Only the most recent tool result stays in full.
+ * Does not mutate the input — returns a new prompt array.
+ */
+export declare function compressIntraTurnToolResults(prompt: LanguageModelV3Prompt, toolResultMaxTokens: number): LanguageModelV3Prompt;
+/**
+ * Estimates the total token count of tool results in the prompt.
+ */
+export declare function estimateToolResultTokens(prompt: LanguageModelV3Prompt): number;
+/**
+ * When accumulated tool result tokens exceed the threshold, summarizes
+ * older step results using a lightweight LLM call.
+ *
+ * Replaces all tool results except the last two with a single synthetic
+ * summary in the oldest tool message.
+ */
+export declare function summarizeOldStepResults(prompt: LanguageModelV3Prompt, thresholdTokens: number, modelConfig: SummarizationModelConfig): Promise<LanguageModelV3Prompt>;
+export {};

package/dist/src/{ai → lib/ai}/context/types.d.ts

@@ -10,6 +10,8 @@ export type ContextConfig = {
     };
     toolResultMaxTokens: number;
     recentMessagesToKeep: number;
+    /** Token threshold for triggering intra-turn summarization of older tool results */
+    intraTurnSummarizationThresholdTokens: number;
 };
 export type ThreadContextMeta = {
     summary: string | null;

package/dist/src/lib/config.d.ts

@@ -0,0 +1,153 @@
+import type { ToolSet, UIMessage } from "ai";
+import type { DatabaseAdapter } from "./adapters/database";
+import type { StorageAdapter } from "./adapters/storage";
+import type { DomainDef } from "./graph/types.ts";
+import type { RequestInterceptorOptions } from "./ai/interceptors/request-interceptor.ts";
+import type { ContextConfig } from "./ai/context/types.ts";
+import type { Thread } from "./types.ts";
+type ModelConfig = {
+    baseURL: string;
+    apiKey: string;
+    modelName: string;
+    providerName?: string;
+};
+type EmbeddingConfig = {
+    baseURL: string;
+    apiKey: string;
+    modelName: string;
+    dimension: number;
+};
+type Neo4jConfig = {
+    url: string;
+    user: string;
+    password: string;
+};
+type RerankerConfig = {
+    url: string;
+    apiKey: string;
+};
+export type KnowledgeConfig = {
+    swagger?: {
+        url: string;
+    };
+    domains?: Record<string, DomainDef>;
+};
+export type PromptContext<TSession extends Record<string, unknown> = Record<string, unknown>, TRequestContext extends Record<string, unknown> = Record<string, unknown>> = {
+    session: TSession | null;
+    requestContext: TRequestContext;
+};
+/**
+ * Per-request context handed to a tools factory. Allows tool implementations to
+ * close over the active thread, user, session, and request-level context without
+ * reaching for globals or AsyncLocalStorage.
+ */
+export type ToolContext<TSession extends Record<string, unknown> = Record<string, unknown>, TRequestContext extends Record<string, unknown> = Record<string, unknown>> = {
+    thread: Thread;
+    userId: string;
+    token: string;
+    session: TSession | null;
+    requestContext: TRequestContext;
+};
+export type ToolSetFactory<TSession extends Record<string, unknown> = Record<string, unknown>, TRequestContext extends Record<string, unknown> = Record<string, unknown>> = (context: ToolContext<TSession, TRequestContext>) => ToolSet;
+export type DatabaseConfig = {
+    type: "mssql";
+    connectionString: string;
+};
+export type StorageConfig = {
+    endPoint: string;
+    port: number;
+    useSSL: boolean;
+    accessKey: string;
+    secretKey: string;
+    bucketName?: string;
+};
+export type CortexAgentDefinition<TSession extends Record<string, unknown> = Record<string, unknown>, TRequestContext extends Record<string, unknown> = Record<string, unknown>> = {
+    systemPrompt: string | ((context: PromptContext<TSession, TRequestContext>) => string | Promise<string>);
+    tools?: ToolSet | ToolSetFactory<TSession, TRequestContext>;
+    backendFetch?: {
+        baseUrl: string;
+        apiKey: string;
+        headers?: Record<string, string>;
+        transformRequestBody?: (body: Record<string, unknown>, context: {
+            token: string;
+        }) => Promise<Record<string, unknown>>;
+        interceptor?: RequestInterceptorOptions;
+    };
+    loadSessionData?: (token: string) => Promise<TSession>;
+    resolveRequestContext?: (request: Request) => TRequestContext | Promise<TRequestContext>;
+    onToolCall?: (toolCall: {
+        toolName: string;
+        toolCallId: string;
+        args: Record<string, unknown>;
+    }) => void;
+    onStreamFinish?: (result: {
+        messages: UIMessage[];
+        isAborted: boolean;
+    }) => void;
+    model?: ModelConfig;
+    fastModel?: ModelConfig;
+    embedding?: EmbeddingConfig;
+    neo4j?: Neo4jConfig;
+    reranker?: RerankerConfig;
+    context?: Partial<ContextConfig>;
+    knowledge?: KnowledgeConfig | null;
+};
+export type ResolvedCortexAgentConfig = {
+    db: DatabaseAdapter;
+    storage: StorageAdapter;
+    model: ModelConfig;
+    fastModel?: ModelConfig;
+    embedding: EmbeddingConfig;
+    neo4j?: Neo4jConfig;
+    reranker?: RerankerConfig;
+    systemPrompt: string | ((context: PromptContext) => string | Promise<string>);
+    tools?: ToolSet | ToolSetFactory;
+    backendFetch?: {
+        baseUrl: string;
+        apiKey: string;
+        headers?: Record<string, string>;
+        transformRequestBody?: (body: Record<string, unknown>, context: {
+            token: string;
+        }) => Promise<Record<string, unknown>>;
+        interceptor?: RequestInterceptorOptions;
+    };
+    loadSessionData?: (token: string) => Promise<Record<string, unknown>>;
+    resolveRequestContext?: (request: Request) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    onToolCall?: (toolCall: {
+        toolName: string;
+        toolCallId: string;
+        args: Record<string, unknown>;
+    }) => void;
+    onStreamFinish?: (result: {
+        messages: UIMessage[];
+        isAborted: boolean;
+    }) => void;
+    context: ContextConfig;
+    knowledge?: KnowledgeConfig;
+};
+export type CortexConfig = {
+    port?: number;
+    database: DatabaseConfig;
+    storage: StorageConfig;
+    auth?: {
+        jwksUri: string;
+        issuer: string;
+        tokenExtractor?: (req: Request) => string | null;
+        cookieName?: string;
+    };
+    model: ModelConfig;
+    fastModel?: ModelConfig;
+    embedding: EmbeddingConfig;
+    neo4j?: Neo4jConfig;
+    reranker?: RerankerConfig;
+    context?: Partial<ContextConfig>;
+    knowledge?: KnowledgeConfig;
+    agents: Record<string, CortexAgentDefinition>;
+};
+/**
+ * Helper to define an agent with full type inference for `systemPrompt` context.
+ * The `context.session` type is inferred from `loadSessionData`'s return type,
+ * and `context.requestContext` is inferred from `resolveRequestContext`'s return type.
+ */
+export declare function defineAgent<TSession extends Record<string, unknown> = Record<string, unknown>, TRequestContext extends Record<string, unknown> = Record<string, unknown>>(config: CortexAgentDefinition<TSession, TRequestContext>): CortexAgentDefinition;
+export {};

package/dist/src/{db → lib/db}/schema.d.ts

@@ -1,5 +1,5 @@
 import type { UIMessage } from "ai";
-import type { MessageMetadata } from "src/types";
+import type { MessageMetadata, TokenUsage } from "../types.ts";
 import type { ThreadContextMeta } from "../ai/context/types.ts";
 export declare const aiSchema: import("drizzle-orm/mssql-core").MsSqlSchema<"ai">;
 export declare const threads: import("drizzle-orm/mssql-core").MsSqlTableWithColumns<{
@@ -256,6 +256,109 @@ export declare const messages: import("drizzle-orm/mssql-core").MsSqlTableWithCo
     };
     dialect: "mssql";
 }>;
+export declare const llmRequests: import("drizzle-orm/mssql-core").MsSqlTableWithColumns<{
+    name: "llm_requests";
+    schema: "ai";
+    columns: {
+        id: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "llm_requests";
+            dataType: "custom";
+            data: string;
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        messageId: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "llm_requests";
+            dataType: "string";
+            data: string;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        stepNumber: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "llm_requests";
+            dataType: "number int32";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        prompt: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "llm_requests";
+            dataType: "string";
+            data: string;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        output: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "llm_requests";
+            dataType: "string";
+            data: string;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        tokenUsage: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "llm_requests";
+            dataType: "object json";
+            data: TokenUsage;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: "mssql";
+}>;
 export declare const capturedFiles: import("drizzle-orm/mssql-core").MsSqlTableWithColumns<{
     name: "captured_files";
     schema: "ai";

package/dist/src/{index.d.ts → lib/index.d.ts}

@@ -1,4 +1,5 @@
-export type { CortexConfig, CortexAgentDefinition, KnowledgeConfig, DatabaseConfig, StorageConfig, PromptContext, } from "./config";
+export type { CortexConfig, CortexAgentDefinition, KnowledgeConfig, DatabaseConfig, StorageConfig, PromptContext, ToolContext, ToolSetFactory, } from "./config";
+export { defineAgent } from "./config";
 export type { ContextConfig, ThreadContextMeta } from "./ai/context/types";
 export type { Thread, AppEnv } from "./types";
 export type { CortexInstance } from "./factory";
@@ -7,7 +8,6 @@ export type { ResolvedFile, RequestInterceptorOptions, } from "./ai/interceptors
 export { createRequestInterceptor } from "./ai/interceptors/request-interceptor";
 export { captureFilesTool } from "./ai/tools/capture-files.tool";
 export { createQueryGraphTool } from "./ai/tools/query-graph.tool";
-export { createCallEndpointTool } from "./ai/tools/call-endpoint.tool";
 export { createExecuteCodeTool } from "./ai/tools/execute-code.tool";
 export * from "./graph/index";
 export type { WsEvent, ThreadTitleUpdatedEvent } from "./ws/index";

package/dist/src/{types.d.ts → lib/types.d.ts}

@@ -10,24 +10,25 @@ export type ThreadSummary = {
     updatedAt: Date;
     isRunning: boolean;
 };
+export type TokenUsage = {
+    input: {
+        noCache: number;
+        cacheRead: number;
+        cacheWrite: number;
+        total: number;
+    };
+    output: {
+        reasoning: number;
+        text: number;
+        total: number;
+    };
+    total: number;
+};
 export type MessageMetadata = {
     modelId: string;
     providerMetadata: unknown;
     isAborted?: boolean;
-    tokenUsage?: {
-        input: {
-            noCache: number;
-            cacheRead: number;
-            cacheWrite: number;
-            total: number;
-        };
-        output: {
-            reasoning: number;
-            text: number;
-            total: number;
-        };
-        total: number;
-    };
+    tokenUsage?: TokenUsage;
 };
 export type CapturedFileInput = {
     id: string;

package/index.ts

@@ -1 +1 @@
-export * from "./src/index";
+export * from "./src/lib/index";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@m6d/cortex-server",
-    "version": "1.6.0",
+    "version": "1.8.0",
     "description": "Reusable AI agent chat server library for Hono + Bun",
     "license": "MIT",
     "type": "module",
@@ -22,7 +22,10 @@
     "scripts": {
         "build": "tsc -p tsconfig.build.json",
         "db:generate": "drizzle-kit generate",
-        "db:migrate": "drizzle-kit migrate"
+        "db:migrate": "drizzle-kit migrate",
+        "db:sample:generate": "drizzle-kit generate --config ./src/sample/drizzle.config.ts",
+        "db:sample:migrate": "drizzle-kit migrate --config ./src/sample/drizzle.config.ts",
+        "dev": "bun run --hot src/sample/index.ts"
     },
     "dependencies": {
         "@ai-sdk/provider": "^3.0.0",
@@ -40,7 +43,9 @@
         "ai": "^6.0.104",
         "drizzle-kit": "^1.0.0-beta.15-859cf75",
         "hono": "^4.12.3",
-        "typescript": "^5"
+        "jose": "^6.1.3",
+        "typescript": "^5",
+        "zod": "^4.3.6"
     },
     "peerDependencies": {
         "@ai-sdk/openai-compatible": "^2.0.0",

package/src/{adapters → lib/adapters}/database.ts

@@ -1,5 +1,5 @@
 import type { ToolUIPart, UIMessage } from "ai";
-import type { Thread, StoredMessage, CapturedFileInput } from "../types";
+import type { Thread, StoredMessage, CapturedFileInput, TokenUsage } from "../types";
 import type { ThreadContextMeta } from "../ai/context/types.ts";
 
 export type DatabaseAdapter = {
@@ -17,6 +17,25 @@ export type DatabaseAdapter = {
         list(userId: string, threadId: string, opts?: { limit?: number }): Promise<StoredMessage[]>;
         upsert(threadId: string, messages: UIMessage[]): Promise<void>;
     };
+    llmRequests: {
+        insert(
+            requests: {
+                messageId: string;
+                stepNumber: number;
+                prompt: string;
+                output: string | null;
+                tokenUsage: TokenUsage | null;
+            }[],
+        ): Promise<void>;
+        listByMessageId(messageId: string): Promise<
+            {
+                id: string;
+                prompt: string;
+                output: string | null;
+                tokenUsage: TokenUsage | null;
+            }[]
+        >;
+    };
     capturedFiles: {
         create(
             userId: string,

package/src/{adapters → lib/adapters}/minio.ts

@@ -41,7 +41,8 @@ export function createMinioAdapter(config: MinioConfig) {
                 await ensureBucket();
                 await client.putObject(bucketName, path, Buffer.from(data, "base64"));
                 return true;
-            } catch {
+            } catch (e) {
+                console.log(e);
                 return false;
             }
         },

package/src/{adapters → lib/adapters}/mssql.ts

@@ -1,7 +1,7 @@
 import type { ToolUIPart, UIMessage } from "ai";
-import { and, desc, eq, getColumns, inArray, type InferInsertModel } from "drizzle-orm";
+import { and, asc, desc, eq, getColumns, inArray, type InferInsertModel } from "drizzle-orm";
 import { drizzle } from "drizzle-orm/node-mssql";
-import { threads, messages, capturedFiles } from "../db/schema";
+import { threads, messages, capturedFiles, llmRequests } from "../db/schema";
 import type { DatabaseAdapter } from "./database";
 import type { StorageAdapter } from "./storage";
 import type { Thread, CapturedFileInput, MessageMetadata } from "../types";
@@ -142,6 +142,42 @@ export function createMssqlAdapter(connectionString: string, storage: StorageAda
             },
         },
 
+        llmRequests: {
+            async insert(requests) {
+                if (!requests.length) return;
+
+                await db
+                    .insert(llmRequests)
+                    .values(
+                        requests.map(
+                            (r) =>
+                                ({
+                                    messageId: r.messageId,
+                                    stepNumber: r.stepNumber,
+                                    prompt: r.prompt,
+                                    output: r.output,
+                                    tokenUsage: r.tokenUsage,
+                                }) satisfies InferInsertModel<typeof llmRequests>,
+                        ),
+                    )
+                    .execute();
+            },
+
+            async listByMessageId(messageId) {
+                return await db
+                    .select({
+                        id: llmRequests.id,
+                        prompt: llmRequests.prompt,
+                        output: llmRequests.output,
+                        tokenUsage: llmRequests.tokenUsage,
+                    })
+                    .from(llmRequests)
+                    .where(eq(llmRequests.messageId, messageId))
+                    .orderBy(asc(llmRequests.stepNumber))
+                    .execute();
+            },
+        },
+
         capturedFiles: {
             async create(
                 userId: string,