@m6d/cortex-server 1.8.0 → 2.0.1

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/lib/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/lib/adapters/{minio.d.ts → 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" | "utcTime" | "timezone")[];
+        catalogBlurb: string;
+        defaultLocale: "ar" | "en";
+        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: "ar" | "en";
+    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/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[];

package/dist/src/lib/ai/context/compression-middleware.d.ts

@@ -0,0 +1,15 @@
+import type { ResolvedCortexAgentConfig } from "../../config";
+/**
+ * Keeps a single turn's tool results inside the context window as steps accumulate.
+ *
+ * `onConfig` runs before every model call in the agent loop. Truncating older results
+ * is free, so it always happens; summarizing costs an extra model call and only
+ * happens if truncation left us over the threshold. A failed summarization is logged
+ * and swallowed — degrading to the merely-truncated prompt beats failing the turn.
+ */
+export declare function createCompressionMiddleware(config: ResolvedCortexAgentConfig): {
+    name: string;
+    onConfig(_ctx: import("@tanstack/ai").ChatMiddlewareContext<unknown>, { messages }: import("@tanstack/ai").ChatMiddlewareConfig): Promise<{
+        messages: import("@tanstack/ai").ModelMessage<string | import("@tanstack/ai").ContentPart<unknown, unknown, unknown, unknown, unknown>[] | null>[];
+    }>;
+};

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

@@ -1,18 +1,7 @@
-import type { UIMessage } from "ai";
-import type { MessageMetadata } from "../../types.ts";
+import type { ChatMessage } from "../../types";
 /**
  * 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 compressToolResults(messages: ChatMessage[], maxTokensPerResult: number): ChatMessage[];
 export declare function summarizeValue(val: unknown): string;

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

@@ -1,24 +1,24 @@
-import type { LanguageModelV3Prompt } from "@ai-sdk/provider";
-import type { ContextConfig } from "./types.ts";
+import type { ModelMessage } from "@tanstack/ai";
+import type { ContextConfig } from "./types";
 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.
+ * to short one-liners. Only the most recent step's results stay in full.
+ * Does not mutate the input — returns a new array.
  */
-export declare function compressIntraTurnToolResults(prompt: LanguageModelV3Prompt, toolResultMaxTokens: number): LanguageModelV3Prompt;
+export declare function compressIntraTurnToolResults(messages: ModelMessage[], toolResultMaxTokens: number): ModelMessage<string | import("@tanstack/ai").ContentPart<unknown, unknown, unknown, unknown, unknown>[] | null>[];
 /**
  * Estimates the total token count of tool results in the prompt.
  */
-export declare function estimateToolResultTokens(prompt: LanguageModelV3Prompt): number;
+export declare function estimateToolResultTokens(messages: ModelMessage[]): 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.
+ * Replaces every tool result before the last two steps with a single
+ * synthetic summary in the oldest tool message.
  */
-export declare function summarizeOldStepResults(prompt: LanguageModelV3Prompt, thresholdTokens: number, modelConfig: SummarizationModelConfig): Promise<LanguageModelV3Prompt>;
+export declare function summarizeOldStepResults(messages: ModelMessage[], thresholdTokens: number, modelConfig: SummarizationModelConfig): Promise<ModelMessage<string | import("@tanstack/ai").ContentPart<unknown, unknown, unknown, unknown, unknown>[] | null>[]>;
 export {};

package/dist/src/lib/ai/context/optimize-thread-context.d.ts

@@ -0,0 +1,9 @@
+import type { ResolvedCortexAgentConfig } from "../../config";
+import type { ChatMessage, Thread } from "../../types";
+/**
+ * Post-response context optimization, called fire-and-forget from onFinish.
+ *
+ * Below the summarization threshold this only refreshes the token estimate —
+ * summarizing early would burn a model call to compress context that still fits.
+ */
+export declare function optimizeThreadContext(thread: Thread, messages: ChatMessage[], config: ResolvedCortexAgentConfig): Promise<void>;

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

@@ -1,5 +1,5 @@
-import type { UIMessage } from "ai";
-import type { ContextConfig } from "./types.ts";
+import type { ChatMessage } from "../../types";
+import type { ContextConfig } from "./types";
 type SummarizationModelConfig = NonNullable<ContextConfig["summarizationModel"]>;
-export declare function summarizeMessages(messages: UIMessage[], existingSummary: string | null, modelConfig: SummarizationModelConfig): Promise<string>;
+export declare function summarizeMessages(messages: ChatMessage[], existingSummary: string | null, modelConfig: SummarizationModelConfig): Promise<string>;
 export {};

package/dist/src/lib/ai/context/token-estimator.d.ts

@@ -1,4 +1,4 @@
-import type { UIMessage } from "ai";
+import type { ChatMessage } from "../../types";
 /** Average characters per token for English text. Used by the heuristic estimator. */
 export declare const CHARS_PER_TOKEN = 4;
 /**
@@ -6,15 +6,12 @@ export declare const CHARS_PER_TOKEN = 4;
  * ~10% accuracy for English text — good enough for budget decisions.
  */
 export declare function estimateTokens(text: string): number;
+export declare function estimateMessageTokens(message: ChatMessage): number;
 /**
- * Estimates token count for a single UIMessage by walking its parts.
- */
-export declare function estimateMessageTokens(message: UIMessage): number;
-/**
- * Estimates token counts for an array of UIMessages.
+ * Estimates token counts for an array of messages.
  * Returns per-message estimates in the same order.
  */
-export declare function estimateMessagesTokens(messages: UIMessage[]): {
-    message: UIMessage<unknown, import("ai").UIDataTypes, import("ai").UITools>;
+export declare function estimateMessagesTokens(messages: ChatMessage[]): {
+    message: ChatMessage;
     tokens: number;
 }[];

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

@@ -1,2 +1,2 @@
-import type { ResolvedCortexAgentConfig } from "../config.ts";
+import type { ResolvedCortexAgentConfig } from "../config";
 export declare function fetchBackend(path: string, backendFetch: NonNullable<ResolvedCortexAgentConfig["backendFetch"]>, token: string, options?: RequestInit): Promise<Response>;

package/dist/src/lib/ai/finish-turn.d.ts

@@ -0,0 +1,23 @@
+import type { ResolvedCortexAgentConfig } from "../config";
+import type { ChatMessage, Thread } from "../types";
+import type { CapturedStep } from "./inspector";
+type FinishTurnOptions = {
+    /** What this run produced — the only messages the turn writes. */
+    messages: ChatMessage[];
+    /** The thread including them, which is what a summary has to be judged against. */
+    threadMessages: ChatMessage[];
+    isAborted: boolean;
+    assistantMessageId: string | undefined;
+    thread: Thread;
+    userId: string;
+    capturedSteps: CapturedStep[];
+    config: ResolvedCortexAgentConfig;
+};
+/**
+ * Persists everything a completed turn produced, then tells the client to refetch.
+ *
+ * The thread is re-read first: it may have been deleted mid-stream, in which case
+ * there is nothing to write to and the whole turn is discarded.
+ */
+export declare function finishTurn(options: FinishTurnOptions): Promise<void>;
+export {};

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

@@ -1,5 +1,38 @@
-import type { ResolvedCortexAgentConfig } from "../config.ts";
-export declare function createModel(config: ResolvedCortexAgentConfig["model"]): import("@ai-sdk/provider").LanguageModelV3;
-export declare function createEmbeddingModel(config: ResolvedCortexAgentConfig["embedding"]): import("@ai-sdk/provider").EmbeddingModelV3;
+import { OpenAICompatibleChatAdapter } from "@tanstack/ai-openai/compatible";
+/** Everything cortex needs to reach one OpenAI-compatible chat endpoint. */
+export type ProviderConfig = {
+    baseURL: string;
+    apiKey: string;
+    modelName: string;
+    providerName?: string;
+};
+/**
+ * `openaiCompatible()` drops streamed reasoning: its `extractReasoning` hook is
+ * a no-op and nothing shipped overrides it. Cortex renders thinking parts, so it
+ * takes the sanctioned subclass seam and reads the `reasoning_content` delta.
+ */
+declare class ReasoningChatAdapter extends OpenAICompatibleChatAdapter<string> {
+    protected extractReasoning(chunk: unknown): {
+        text: string;
+    } | undefined;
+}
+/**
+ * `fetch` is how the caller observes or rewrites the raw HTTP exchange — the LLM
+ * inspector captures through it, the vision model adapts `max_tokens` through it.
+ */
+export declare function createModel(config: ProviderConfig, options?: {
+    name?: string;
+    fetch?: typeof globalThis.fetch;
+}): ReasoningChatAdapter;
+/** Vision calls cap output tokens, so they need the max_tokens parameter shim. */
+export declare function createVisionModel(config: ProviderConfig): ReasoningChatAdapter;
 export declare function streamToBase64(stream: ReadableStream<Uint8Array>): Promise<string>;
-export declare function tokenToUserId(token: string): string;
+/**
+ * OpenAI's newer models reject `max_tokens` in favor of `max_completion_tokens`,
+ * while most OpenAI-compatible gateways only accept `max_tokens`. Retry once on
+ * that specific rejection and remember the answer for this fetch's lifetime.
+ */
+export declare function createMaxTokensAdaptingFetch(): ((input: string | URL | Request, init?: RequestInit) => Promise<Response>) & {
+    preconnect: typeof fetch.preconnect;
+};
+export {};

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

@@ -1,4 +1,7 @@
-import type { ResolvedCortexAgentConfig } from "../config.ts";
-import type { Thread } from "../types.ts";
-export declare function stream(messages: unknown[], thread: Thread, userId: string, token: string, requestContext: Record<string, unknown>, config: ResolvedCortexAgentConfig): Promise<Response>;
+import { chatParamsFromRequest } from "@tanstack/ai";
+import type { ResolvedCortexAgentConfig } from "../config";
+import type { Thread } from "../types";
+/** The AG-UI request body, as the route parsed it. */
+export type TurnParams = Awaited<ReturnType<typeof chatParamsFromRequest>>;
+export declare function startTurn(params: TurnParams, thread: Thread, userId: string, token: string, requestContext: Record<string, unknown>, config: ResolvedCortexAgentConfig): Promise<Response | null>;
 export declare function generateTitle(threadId: string, prompt: string, userId: string, config: ResolvedCortexAgentConfig): Promise<void>;

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

@@ -0,0 +1,41 @@
+import type { ChatMiddleware, TokenUsage as ProviderTokenUsage } from "@tanstack/ai";
+import type { TokenUsage } from "../types";
+/** One model call's raw exchange, as the LLM request inspector renders it. */
+export type CapturedStep = {
+    prompt: string;
+    output: string | null;
+    tokenUsage: TokenUsage | null;
+};
+/**
+ * Watches one turn's model calls. The SDK's `debug` logger reports call metadata
+ * but never raw bodies, so the raw exchange is captured where it actually
+ * exists — on the HTTP client — while usage arrives through middleware.
+ */
+export declare function createInspector(): {
+    steps: CapturedStep[];
+    middleware: ChatMiddleware<unknown>;
+    fetch: ((input: string | URL | Request, init?: RequestInit) => Promise<Response>) & {
+        preconnect: typeof fetch.preconnect;
+    };
+    readonly modelId: string;
+    readonly tokenUsage: TokenUsage | undefined;
+};
+/**
+ * Flattens the provider's usage shape into ours. The provider reports cached and
+ * cache-written prompt tokens but no uncached counter, so that dimension is the
+ * remainder — which is what makes the client's breakdown add up to the total.
+ */
+export declare function toTokenUsage(usage: ProviderTokenUsage): {
+    input: {
+        noCache: number;
+        cacheRead: number;
+        cacheWrite: number;
+        total: number;
+    };
+    output: {
+        reasoning: number;
+        text: number;
+        total: number;
+    };
+    total: number;
+};

package/dist/src/lib/ai/interceptors/request-interceptor.d.ts

@@ -1,5 +1,5 @@
-import type { DatabaseAdapter } from "../../adapters/database.ts";
-import type { StorageAdapter } from "../../adapters/storage.ts";
+import type { DatabaseAdapter } from "../../adapters/database/index";
+import type { StorageAdapter } from "../../adapters/storage/index";
 export type ResolvedFile = {
     name: string;
     bytes: string;
@@ -7,6 +7,7 @@ export type ResolvedFile = {
 export type RequestInterceptorOptions = {
     transformFile?: (file: ResolvedFile) => unknown;
 };
-export declare function createRequestInterceptor(db: DatabaseAdapter, storage: StorageAdapter, options?: RequestInterceptorOptions): (body: Record<string, unknown>, context: {
-    token: string;
-}) => Promise<Record<string, unknown>>;
+export declare function createRequestInterceptor(db: DatabaseAdapter, storage: StorageAdapter, options: RequestInterceptorOptions & {
+    threadId: string;
+    userId: string;
+}): (body: Record<string, unknown>) => Promise<Record<string, unknown>>;

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

@@ -1,9 +1,10 @@
-import type { ResolvedContext } from "../graph/resolver.ts";
-import type { PromptContext, ResolvedCortexAgentConfig } from "../config.ts";
-import type { Thread } from "../types.ts";
+import type { ResolvedContext } from "../graph/resolver";
+import type { PromptContext, ResolvedCortexAgentConfig } from "../config";
+import type { Thread } from "../types";
+import type { CcPromptInput } from "../cc/format";
 /**
  * Resolves session data for the thread, loading from the configured
  * session loader if not already cached on the thread.
  */
 export declare function resolveSession(config: ResolvedCortexAgentConfig, thread: Thread, token: string): Promise<Record<string, unknown> | null>;
-export declare function buildSystemPrompt(config: ResolvedCortexAgentConfig, resolved: ResolvedContext | null, promptContext: PromptContext): Promise<string>;
+export declare function buildSystemPrompt(config: ResolvedCortexAgentConfig, resolved: ResolvedContext | null, promptContext: PromptContext, cc?: CcPromptInput, attachmentListing?: string): Promise<string>;

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

@@ -0,0 +1,41 @@
+import type { RedisConnections } from "../redis";
+import type { ActiveRun } from "./active-runs";
+import { offsetBelongsToRun } from "./redis-stream-log";
+type RedisRunOptions = {
+    streamTtlSeconds?: number;
+};
+export declare function createRedisRuns(connections: RedisConnections, options?: RedisRunOptions): {
+    startRun(threadId: string): Promise<ActiveRun>;
+    getRunId(threadId: string): Promise<string | undefined>;
+    runningThreadIds(threadIds: string[]): Promise<Set<string>>;
+    abortRun: (threadId: string) => Promise<boolean>;
+    endRun(threadId: string, runId: string): Promise<void>;
+    producerLog(runId: string): {
+        resumeFrom: () => string | null;
+        append: (chunks: import("@tanstack/ai").AGUIEvent[]) => Promise<string[]>;
+        snapshot: () => Promise<{
+            offset: string;
+            chunk: import("@tanstack/ai").StreamChunk;
+        }[]>;
+        close: () => Promise<void>;
+        read: (offset: string, signal?: AbortSignal) => AsyncGenerator<{
+            offset: string;
+            chunk: import("@tanstack/ai").StreamChunk;
+        }, void, any>;
+    };
+    joinLog(threadId: string, runId: string, offset?: string | undefined): {
+        resumeFrom: () => string | null;
+        append: (chunks: import("@tanstack/ai").AGUIEvent[]) => Promise<string[]>;
+        snapshot: () => Promise<{
+            offset: string;
+            chunk: import("@tanstack/ai").StreamChunk;
+        }[]>;
+        close: () => Promise<void>;
+        read: (offset: string, signal?: AbortSignal) => AsyncGenerator<{
+            offset: string;
+            chunk: import("@tanstack/ai").StreamChunk;
+        }, void, any>;
+    };
+    offsetBelongsToRun: typeof offsetBelongsToRun;
+};
+export {};