@m6d/cortex-server 1.7.0 → 2.0.0

package/dist/src/lib/adapters/database/postgres/attachments.d.ts

@@ -0,0 +1,113 @@
+import type { PostgresDb } from "./client";
+export declare function createAttachmentsRepository(db: PostgresDb): {
+    createPending(row: {
+        userId: string;
+        threadId: string;
+        filename: string;
+        contentType: string;
+        sizeBytes: number;
+        storageKey: string;
+        status: "pending" | "described" | "failed" | "skipped";
+        id?: string | undefined;
+        createdAt?: Date | undefined;
+        updatedAt?: Date | undefined;
+        messageId?: string | null | undefined;
+        description?: string | null | undefined;
+    }, limit: number): Promise<{
+        id: string;
+        userId: string;
+        createdAt: Date;
+        updatedAt: Date;
+        threadId: string;
+        messageId: string | null;
+        filename: string;
+        contentType: string;
+        sizeBytes: number;
+        storageKey: string;
+        status: "pending" | "described" | "failed" | "skipped";
+        description: string | null;
+    } | undefined>;
+    getById(id: string, userId: string): Promise<{
+        id: string;
+        userId: string;
+        createdAt: Date;
+        updatedAt: Date;
+        threadId: string;
+        messageId: string | null;
+        filename: string;
+        contentType: string;
+        sizeBytes: number;
+        storageKey: string;
+        status: "pending" | "described" | "failed" | "skipped";
+        description: string | null;
+    } | {
+        createdAt: Date;
+        updatedAt: Date;
+        id: string;
+        threadId: string;
+        userId: string;
+        messageId: string | null;
+        filename: string;
+        contentType: string;
+        sizeBytes: number;
+        storageKey: string;
+        status: "pending" | "described" | "failed" | "skipped";
+        description: string | null;
+    } | undefined>;
+    listByThread(threadId: string, userId: string): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        id: string;
+        threadId: string;
+        userId: string;
+        messageId: string | null;
+        filename: string;
+        contentType: string;
+        sizeBytes: number;
+        storageKey: string;
+        status: "pending" | "described" | "failed" | "skipped";
+        description: string | null;
+    }[]>;
+    claimForMessage(threadId: string, userId: string, messageId: string): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        id: string;
+        threadId: string;
+        userId: string;
+        messageId: string | null;
+        filename: string;
+        contentType: string;
+        sizeBytes: number;
+        storageKey: string;
+        status: "pending" | "described" | "failed" | "skipped";
+        description: string | null;
+    }[]>;
+    setDescription(id: string, userId: string, status: "pending" | "described" | "failed" | "skipped", description: string | undefined): Promise<void>;
+    remove(id: string, userId: string): Promise<{
+        id: string;
+        userId: string;
+        createdAt: Date;
+        updatedAt: Date;
+        threadId: string;
+        messageId: string | null;
+        filename: string;
+        contentType: string;
+        sizeBytes: number;
+        storageKey: string;
+        status: "pending" | "described" | "failed" | "skipped";
+        description: string | null;
+    } | {
+        id: string;
+        userId: string;
+        createdAt: Date;
+        updatedAt: Date;
+        threadId: string;
+        messageId: string | null;
+        filename: string;
+        contentType: string;
+        sizeBytes: number;
+        storageKey: string;
+        status: "pending" | "described" | "failed" | "skipped";
+        description: string | null;
+    } | undefined>;
+};

package/dist/src/lib/adapters/database/postgres/client.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Global snake_case mapping means schema columns are never spelled out twice —
+ * the TypeScript name is the source of truth and Drizzle derives the column.
+ */
+export declare function createPostgresDb(connectionString: string): import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, never>, import("drizzle-orm").EmptyRelations> & {
+    $client: import("pg").Pool;
+};
+export type PostgresDb = ReturnType<typeof createPostgresDb>;

package/dist/src/lib/adapters/database/postgres/index.d.ts

@@ -0,0 +1,207 @@
+import type { StorageAdapter } from "../../../adapters/storage/index";
+/**
+ * The Postgres implementation of the database contract. One repository per
+ * table; only threads takes storage, because deleting a thread is the one
+ * operation that also has to reach into object storage.
+ */
+export declare function createPostgresAdapter(connectionString: string, storage?: StorageAdapter): {
+    threads: {
+        list(userId: string, agentId: string): Promise<{
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            userId: string;
+            agentId: string;
+            title: string | null;
+            session: Record<string, unknown> | null;
+            contextMeta: import("../../..").ThreadContextMeta | null;
+        }[]>;
+        getById(userId: string, threadId: string): Promise<{
+            id: string;
+            userId: string;
+            agentId: string;
+            title: string | null;
+            session: Record<string, unknown> | null;
+            contextMeta: import("../../..").ThreadContextMeta | null;
+            createdAt: Date;
+            updatedAt: Date;
+        } | null>;
+        create(userId: string, agentId: string): Promise<{
+            id: string;
+            userId: string;
+            agentId: string;
+            title: string | null;
+            session: Record<string, unknown> | null;
+            contextMeta: import("../../..").ThreadContextMeta | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }>;
+        delete(userId: string, threadId: string): Promise<void>;
+        touch(threadId: string): Promise<{
+            id: string;
+            userId: string;
+            agentId: string;
+            title: string | null;
+            session: Record<string, unknown> | null;
+            contextMeta: import("../../..").ThreadContextMeta | null;
+            createdAt: Date;
+            updatedAt: Date;
+        }>;
+        updateTitle(threadId: string, title: string): Promise<void>;
+        updateSession(threadId: string, session: Record<string, unknown>): Promise<void>;
+        updateContextMeta(threadId: string, meta: import("../../..").ThreadContextMeta): Promise<void>;
+    };
+    messages: {
+        list(userId: string, threadId: string, opts: {
+            limit?: number;
+        } | undefined): Promise<{
+            id: string;
+            text: string | null;
+            createdAt: Date;
+            updatedAt: Date;
+            threadId: string;
+            content: import("../../../types").ChatMessage;
+            ordinal: number;
+            role: "system" | "user" | "assistant" | "tool";
+        }[] | {
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            threadId: string;
+            text: string | null;
+            content: import("../../../types").ChatMessage;
+            ordinal: number;
+            role: "system" | "user" | "assistant" | "tool";
+        }[]>;
+        upsert(threadId: string, messagesToUpsert: import("../../../types").ChatMessage[], options?: {
+            replaceAttachments?: boolean;
+        }): Promise<void>;
+    };
+    llmRequests: {
+        insert(requests: {
+            messageId: string;
+            stepNumber: number;
+            prompt: string;
+            output: string | null;
+            tokenUsage: import("../../..").TokenUsage | null;
+        }[]): Promise<void>;
+        listByMessageId(messageId: string): Promise<{
+            id: string;
+            prompt: string;
+            output: string | null;
+            tokenUsage: import("../../..").TokenUsage | null;
+        }[]>;
+    };
+    attachments: {
+        createPending(row: {
+            userId: string;
+            threadId: string;
+            filename: string;
+            contentType: string;
+            sizeBytes: number;
+            storageKey: string;
+            status: "pending" | "described" | "failed" | "skipped";
+            id?: string | undefined;
+            createdAt?: Date | undefined;
+            updatedAt?: Date | undefined;
+            messageId?: string | null | undefined;
+            description?: string | null | undefined;
+        }, limit: number): Promise<{
+            id: string;
+            userId: string;
+            createdAt: Date;
+            updatedAt: Date;
+            threadId: string;
+            messageId: string | null;
+            filename: string;
+            contentType: string;
+            sizeBytes: number;
+            storageKey: string;
+            status: "pending" | "described" | "failed" | "skipped";
+            description: string | null;
+        } | undefined>;
+        getById(id: string, userId: string): Promise<{
+            id: string;
+            userId: string;
+            createdAt: Date;
+            updatedAt: Date;
+            threadId: string;
+            messageId: string | null;
+            filename: string;
+            contentType: string;
+            sizeBytes: number;
+            storageKey: string;
+            status: "pending" | "described" | "failed" | "skipped";
+            description: string | null;
+        } | {
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            threadId: string;
+            userId: string;
+            messageId: string | null;
+            filename: string;
+            contentType: string;
+            sizeBytes: number;
+            storageKey: string;
+            status: "pending" | "described" | "failed" | "skipped";
+            description: string | null;
+        } | undefined>;
+        listByThread(threadId: string, userId: string): Promise<{
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            threadId: string;
+            userId: string;
+            messageId: string | null;
+            filename: string;
+            contentType: string;
+            sizeBytes: number;
+            storageKey: string;
+            status: "pending" | "described" | "failed" | "skipped";
+            description: string | null;
+        }[]>;
+        claimForMessage(threadId: string, userId: string, messageId: string): Promise<{
+            createdAt: Date;
+            updatedAt: Date;
+            id: string;
+            threadId: string;
+            userId: string;
+            messageId: string | null;
+            filename: string;
+            contentType: string;
+            sizeBytes: number;
+            storageKey: string;
+            status: "pending" | "described" | "failed" | "skipped";
+            description: string | null;
+        }[]>;
+        setDescription(id: string, userId: string, status: "pending" | "described" | "failed" | "skipped", description: string | undefined): Promise<void>;
+        remove(id: string, userId: string): Promise<{
+            id: string;
+            userId: string;
+            createdAt: Date;
+            updatedAt: Date;
+            threadId: string;
+            messageId: string | null;
+            filename: string;
+            contentType: string;
+            sizeBytes: number;
+            storageKey: string;
+            status: "pending" | "described" | "failed" | "skipped";
+            description: string | null;
+        } | {
+            id: string;
+            userId: string;
+            createdAt: Date;
+            updatedAt: Date;
+            threadId: string;
+            messageId: string | null;
+            filename: string;
+            contentType: string;
+            sizeBytes: number;
+            storageKey: string;
+            status: "pending" | "described" | "failed" | "skipped";
+            description: string | null;
+        } | undefined>;
+    };
+};

package/dist/src/lib/adapters/database/postgres/llm-requests.d.ts

@@ -0,0 +1,17 @@
+import type { PostgresDb } from "./client";
+export declare function createLlmRequestsRepository(db: PostgresDb): {
+    insert(requests: {
+        messageId: string;
+        stepNumber: number;
+        prompt: string;
+        output: string | null;
+        tokenUsage: import("../../..").TokenUsage | null;
+    }[]): Promise<void>;
+    /** Ordered by step so the inspector replays a turn in the order it ran. */
+    listByMessageId(messageId: string): Promise<{
+        id: string;
+        prompt: string;
+        output: string | null;
+        tokenUsage: import("../../..").TokenUsage | null;
+    }[]>;
+};

package/dist/src/lib/adapters/database/postgres/messages.d.ts

@@ -0,0 +1,37 @@
+import type { ChatMessage } from "../../../types";
+import type { PostgresDb } from "./client";
+export declare function createMessagesRepository(db: PostgresDb): {
+    /**
+     * Fetches the newest N and reverses, so a limit keeps the most recent
+     * messages while callers still receive them oldest-first.
+     */
+    list(userId: string, threadId: string, opts: {
+        limit?: number;
+    } | undefined): Promise<{
+        id: string;
+        text: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        threadId: string;
+        content: ChatMessage;
+        ordinal: number;
+        role: "system" | "user" | "assistant" | "tool";
+    }[] | {
+        createdAt: Date;
+        updatedAt: Date;
+        id: string;
+        threadId: string;
+        text: string | null;
+        content: ChatMessage;
+        ordinal: number;
+        role: "system" | "user" | "assistant" | "tool";
+    }[]>;
+    /**
+     * Ids are client-generated, so a turn mixes new messages with edits to
+     * ones already stored. Splitting on existence lets the new ones go in as
+     * a single insert; the rest are updated individually.
+     */
+    upsert(threadId: string, messagesToUpsert: ChatMessage[], options?: {
+        replaceAttachments?: boolean;
+    }): Promise<void>;
+};

package/dist/src/lib/adapters/database/postgres/threads.d.ts

@@ -0,0 +1,50 @@
+import type { ThreadContextMeta } from "../../../ai/context/types";
+import type { PostgresDb } from "./client";
+import type { StorageAdapter } from "../../../adapters/storage/index";
+export declare function createThreadsRepository(db: PostgresDb, storage?: StorageAdapter): {
+    list(userId: string, agentId: string): Promise<{
+        createdAt: Date;
+        updatedAt: Date;
+        id: string;
+        userId: string;
+        agentId: string;
+        title: string | null;
+        session: Record<string, unknown> | null;
+        contextMeta: ThreadContextMeta | null;
+    }[]>;
+    getById(userId: string, threadId: string): Promise<{
+        id: string;
+        userId: string;
+        agentId: string;
+        title: string | null;
+        session: Record<string, unknown> | null;
+        contextMeta: ThreadContextMeta | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    create(userId: string, agentId: string): Promise<{
+        id: string;
+        userId: string;
+        agentId: string;
+        title: string | null;
+        session: Record<string, unknown> | null;
+        contextMeta: ThreadContextMeta | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    /** Object storage has no foreign keys, so attachment paths must be swept before row cascade. */
+    delete(userId: string, threadId: string): Promise<void>;
+    touch(threadId: string): Promise<{
+        id: string;
+        userId: string;
+        agentId: string;
+        title: string | null;
+        session: Record<string, unknown> | null;
+        contextMeta: ThreadContextMeta | null;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    updateTitle(threadId: string, title: string): Promise<void>;
+    updateSession(threadId: string, session: Record<string, unknown>): Promise<void>;
+    updateContextMeta(threadId: string, meta: ThreadContextMeta): Promise<void>;
+};

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

@@ -2,5 +2,5 @@ export type StorageAdapter = {
     put(path: string, data: string): Promise<boolean>;
     get(path: string): Promise<string | false>;
     delete(paths: string[]): Promise<boolean>;
-    stream(path: string): Promise<ReadableStream>;
+    stream(path: string): Promise<ReadableStream<Uint8Array>>;
 };

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

@@ -1,4 +1,4 @@
-import type { StorageAdapter } from "./storage";
+import type { StorageAdapter } from "./index";
 export type MinioConfig = {
     endPoint: string;
     port: number;

package/dist/src/lib/ai/active-runs.d.ts

@@ -0,0 +1,63 @@
+import { type StreamDurability } from "@tanstack/ai";
+/**
+ * The live turn on a thread. Generation runs detached from the HTTP request that
+ * started it, so this registry — not the request — owns the run's lifetime: it is
+ * how abort reaches a producer and how a reconnecting client finds the run to
+ * rejoin.
+ */
+export type ActiveRun = {
+    runId: string;
+    abortController: AbortController;
+};
+/**
+ * One backend owns both halves of a live run: the thread→run claim registry and
+ * the durability log the run streams through. In-memory is the single-process
+ * default; `createCortex({ redis })` swaps in the Redis coordinator so claims,
+ * aborts, and logs survive a producer restart and reach every instance.
+ */
+export type RunCoordinator = {
+    /** Claims the thread for a new run, aborting whatever was running on it. */
+    startRun: (threadId: string) => Promise<ActiveRun>;
+    getRunId: (threadId: string) => Promise<string | undefined>;
+    /** Which of `threadIds` have a live run — one round trip, for list views. */
+    runningThreadIds: (threadIds: string[]) => Promise<Set<string>>;
+    /** Aborts the thread's live run. False when there was none to abort — the
+     *  caller must not report an abort that never happened. */
+    abortRun: (threadId: string) => Promise<boolean>;
+    /** Releases the thread, but only for the run that still holds it — a
+     *  superseded run finishing late must not evict its replacement. */
+    endRun: (threadId: string, runId: string) => Promise<void>;
+    /** The producer's sink: `resumeFrom()` is null, so appends flow into the log. */
+    producerLog: (runId: string) => StreamDurability;
+    /** A reader on the run's log, replaying from `offset` and tailing until close.
+     *  Takes the thread too: the thread's claim is how a reader can tell a live
+     *  producer from a dead one. */
+    joinLog: (threadId: string, runId: string, offset?: string) => StreamDurability;
+    /**
+     * Whether a client-supplied resume offset belongs to `runId`. The offset is
+     * the adapter's own opaque token and names the log it replays — so an offset
+     * naming another run would replay that run's log to whoever presents it.
+     */
+    offsetBelongsToRun: (offset: string, runId: string) => boolean;
+};
+/**
+ * How long a joiner waits for a run's first chunk. The adapter arms this on any
+ * empty log, and it cannot tell "the producer died" from "the producer has not
+ * reached the model yet" — so it has to clear the worst case: a compression
+ * middleware's extra summarization call plus the model's time to first token.
+ * It is generous because it is only a backstop: a producer that fails writes its
+ * own terminal event into the log, and a run that ended is gone from the
+ * registry, so neither ever reaches this timer.
+ */
+export declare const JOIN_FIRST_CHUNK_TIMEOUT_MS: number;
+/** `createCortex` swaps the backend in once at startup; everything below delegates. */
+export declare function configureRunCoordination(backend: RunCoordinator): void;
+export declare function startRun(threadId: string): Promise<ActiveRun>;
+export declare function getRunId(threadId: string): Promise<string | undefined>;
+export declare function isRunning(threadId: string): Promise<boolean>;
+export declare function runningThreadIds(threadIds: string[]): Promise<Set<string>>;
+export declare function abortRun(threadId: string): Promise<boolean>;
+export declare function endRun(threadId: string, runId: string): Promise<void>;
+export declare function producerLog(runId: string): StreamDurability<string>;
+export declare function joinLog(threadId: string, runId: string, offset?: string): StreamDurability<string>;
+export declare function offsetBelongsToRun(offset: string, runId: string): boolean;

package/dist/src/lib/ai/attachments.d.ts

@@ -0,0 +1,30 @@
+import type { ResolvedCortexAgentConfig } from "../config";
+import type { Attachment, ChatMessage } from "../types";
+type PrepareAttachmentsOptions = {
+    config: ResolvedCortexAgentConfig;
+    threadId: string;
+    userId: string;
+    message: ChatMessage;
+    abortSignal?: AbortSignal;
+};
+type AttachmentCapabilities = {
+    readAttachment: boolean;
+    attachmentSentinels: boolean;
+};
+export declare function prepareAttachmentsForTurn(options: PrepareAttachmentsOptions): Promise<{
+    id: string;
+    userId: string;
+    createdAt: Date;
+    updatedAt: Date;
+    threadId: string;
+    messageId: string | null;
+    filename: string;
+    contentType: string;
+    sizeBytes: number;
+    storageKey: string;
+    status: "pending" | "described" | "failed" | "skipped";
+    description: string | null;
+}[]>;
+export declare function buildAttachmentListing(attachmentRows: Attachment[], currentMessageId: string | undefined, capabilities: AttachmentCapabilities): string | undefined;
+export declare function sanitizeAttachmentText(value: string, maxLength?: number): string;
+export {};

package/dist/src/lib/ai/backend-url.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Resolves a backend call target, refusing anything that leaves the configured
+ * origin or escapes its base path.
+ *
+ * `path` arrives from code the model wrote inside the sandbox, so it is untrusted.
+ * Concatenating it onto `baseUrl` was unsafe: when `baseUrl` carries no trailing
+ * slash — the form the docs show — a path of `@evil.test/x` produces
+ * `https://api.example.com@evil.test/x`, where everything before the `@` is read
+ * as userinfo and the host becomes `evil.test`. The request carries the service
+ * API key and the caller's token, so that is a credential leak, not just an SSRF.
+ *
+ * Resolving against an explicitly slash-terminated base also neutralizes
+ * protocol-relative (`//host`) and absolute (`https://host`) paths, which the
+ * origin check below then rejects outright.
+ */
+export declare function resolveBackendUrl(baseUrl: string, path: string): URL;

package/dist/src/lib/ai/cc-runtime.d.ts

@@ -0,0 +1,61 @@
+import type { ResolvedCortexAgentConfig } from "../config";
+import type { Thread } from "../types";
+import type { ControlCenterClient } from "../cc/client";
+import type { CcToolRegistry } from "../cc/registry";
+import type { ResolveResponse, RuntimeAgentConfig } from "../cc/types";
+type CcRuntimeOptions = {
+    ccClient: ControlCenterClient | null;
+    ccConfig: RuntimeAgentConfig | null;
+    ccResolved: ResolveResponse | null;
+    config: ResolvedCortexAgentConfig;
+    thread: Thread;
+    userId: string;
+    token: string;
+    turnKey: string;
+    abortSignal: AbortSignal;
+    getStepIndex: () => number;
+    /** Reports Control Center tools invoked from inside the sandbox, which the
+     *  outer tool instrumentation never sees — it only observes `executeCode`. */
+    onToolProgress: (toolName: string, toolCallId: string, status: "started" | "finished") => void;
+};
+/**
+ * Builds the per-turn Control Center runtime, or undefined when the agent has no
+ * Control Center configured — every consumer treats that as "skip CC entirely".
+ *
+ * Owns the call-index counter, which must restart at zero on each new step so
+ * idempotency keys stay stable when a step is retried.
+ */
+export declare function createCcRuntime(options: CcRuntimeOptions): {
+    client: ControlCenterClient;
+    agentId: string;
+    config: {
+        agentId: string;
+        systemPrompt: string;
+        promptVariables: ("userName" | "channel" | "locale")[];
+        catalogBlurb: string;
+        defaultLocale: "en" | "ar";
+        metaTools: {
+            searchKnowledge: boolean;
+            searchTools: boolean;
+            searchServices: boolean;
+        };
+        limits: {
+            resolveTokenBudget: number;
+            executeTimeoutMs: number;
+            maxResponseBytes: number;
+        };
+        catalogVersion: string;
+        publishedAt: string;
+    };
+    registry: CcToolRegistry;
+    threadId: string;
+    turnKey: string;
+    userId: string;
+    locale: "en" | "ar";
+    endUserToken: string;
+    abortSignal: AbortSignal;
+    getStepIndex: () => number;
+    nextCallIndex(stepIndex: number): number;
+    onToolProgress: (toolName: string, toolCallId: string, status: "started" | "finished") => void;
+} | undefined;
+export {};

package/dist/src/lib/ai/commit-gate.d.ts

@@ -0,0 +1,21 @@
+import { EventType, type StreamChunk, type UIMessage } from "@tanstack/ai";
+type CommitGateOptions = {
+    /** Persists the run's messages. Its rejection is reported to the client. */
+    commit: (messages: UIMessage[]) => Promise<void>;
+    isAborted: () => boolean;
+};
+/**
+ * Rebuilds the run's messages from its own chunks and holds the run's terminal
+ * event back until they are committed, so a client that refetches when the
+ * stream ends can never race the database.
+ *
+ * Only the terminal event ever waits, and it has to be the *last* one rather
+ * than the first: the agent loop emits a terminal event per iteration, and which
+ * one ends the run is only knowable once the stream is exhausted.
+ */
+export declare function commitBeforeTerminal(stream: AsyncIterable<StreamChunk>, options: CommitGateOptions): AsyncGenerator<import("@tanstack/ai").AGUIEvent | {
+    type: EventType.RUN_ERROR;
+    timestamp: number;
+    message: string;
+}, void, unknown>;
+export {};

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

@@ -1,7 +1,6 @@
-import type { UIMessage } from "ai";
-import type { DatabaseAdapter } from "../../adapters/database.ts";
-import type { MessageMetadata, Thread } from "../../types.ts";
-import type { ContextConfig } from "./types.ts";
+import type { DatabaseAdapter } from "../../adapters/database/index";
+import type { ChatMessage, Thread } from "../../types";
+import type { ContextConfig } from "./types";
 /**
  * Builds a token-aware context window from stored messages.
  *
@@ -13,12 +12,12 @@ import type { ContextConfig } from "./types.ts";
  * 6. Prepends summary as synthetic message if older messages were trimmed
  */
 export declare function buildContextMessages(userId: string, thread: Thread, db: DatabaseAdapter, contextConfig: ContextConfig): Promise<{
-    messages: UIMessage<MessageMetadata, import("ai").UIDataTypes, import("ai").UITools>[];
-    allMessages: UIMessage<MessageMetadata, import("ai").UIDataTypes, import("ai").UITools>[];
+    messages: ChatMessage[];
+    allMessages: ChatMessage[];
     summary: string | null;
 }>;
 /**
  * Drops the oldest messages until the total estimated tokens fit within `budget`.
  * Always keeps at least the most recent message.
  */
-export declare function trimMessagesToFit(messages: UIMessage<MessageMetadata>[], budget: number): UIMessage<MessageMetadata, import("ai").UIDataTypes, import("ai").UITools>[];
+export declare function trimMessagesToFit(messages: ChatMessage[], budget: number): ChatMessage[];