@m6d/cortex-server 1.8.0 → 2.0.0

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 {};

package/dist/src/lib/ai/redis-stream-log.d.ts

@@ -0,0 +1,39 @@
+import type { Redis } from "ioredis";
+import type { StreamChunk } from "@tanstack/ai";
+/**
+ * Whether a client-supplied resume offset belongs to `runId`. The offset names
+ * the log it replays, so an offset naming another run would replay that run's
+ * log to whoever presents it — matching the prefix this adapter encodes is what
+ * binds a resume to the thread the caller owns.
+ */
+export declare function offsetBelongsToRun(offset: string, runId: string): boolean;
+type RedisStreamLogOptions = {
+    /** `null` builds a producer (appends flow into the log); an offset builds a reader. */
+    resumeOffset: string | null;
+    /** How long the log stays replayable after its last append or `close()`. */
+    streamTtlMs: number;
+    /** How long a reader waits for the run's first entry before failing. */
+    firstChunkDeadlineMs: number;
+    /**
+     * Whether the run's producer is still alive. While it is, a caught-up
+     * reader parks indefinitely between chunks — the producer owns termination.
+     * Once it reports dead with the log still unclosed, the run was orphaned
+     * (producer crashed before `close()`), and the read fails so the joiner
+     * gets a terminal error instead of tailing forever.
+     */
+    isLive?: () => Promise<boolean>;
+};
+export declare function redisStreamLog(redis: Redis, runId: string, options: RedisStreamLogOptions): {
+    resumeFrom: () => string | null;
+    append: (chunks: import("@tanstack/ai").AGUIEvent[]) => Promise<string[]>;
+    snapshot: () => Promise<{
+        offset: string;
+        chunk: StreamChunk;
+    }[]>;
+    close: () => Promise<void>;
+    read: (offset: string, signal?: AbortSignal) => AsyncGenerator<{
+        offset: string;
+        chunk: StreamChunk;
+    }, void, any>;
+};
+export {};

package/dist/src/lib/ai/tools/execute-code.tool.d.ts

@@ -1,4 +1,18 @@
-import type { ResolvedCortexAgentConfig } from "../../config.ts";
-export declare function createExecuteCodeTool(backendFetch: NonNullable<ResolvedCortexAgentConfig["backendFetch"]>, token: string): import("ai").Tool<{
-    code: string;
-}, string>;
+import z from "zod";
+import type { ResolvedCortexAgentConfig } from "../../config";
+import type { CcRuntime } from "../../cc/registry";
+export type ExecuteCodeToolOptions = {
+    backendFetch?: NonNullable<ResolvedCortexAgentConfig["backendFetch"]>;
+    attachmentSentinels?: boolean;
+    token: string;
+    cc?: CcRuntime;
+};
+export declare function createExecuteCodeTool(options: ExecuteCodeToolOptions): import("@tanstack/ai").ServerTool<z.ZodObject<{
+    code: z.ZodString;
+}, z.core.$strip>, undefined, "executeCode", unknown, false, undefined> & {
+    inputSchema: z.ZodObject<{
+        code: z.ZodString;
+    }, z.core.$strip>;
+    outputSchema: undefined;
+    approvalSchema: undefined;
+};

package/dist/src/lib/ai/tools/query-graph.tool.d.ts

@@ -1,5 +1,13 @@
-import type { Neo4jClient } from "../../graph/neo4j.ts";
-export declare function createQueryGraphTool(neo4j: Neo4jClient): import("ai").Tool<{
-    query: string;
-    parameters?: string | undefined;
-}, string>;
+import z from "zod";
+import type { Neo4jClient } from "../../../../contracts/graph";
+export declare function createQueryGraphTool(neo4j: Neo4jClient): import("@tanstack/ai").ServerTool<z.ZodObject<{
+    query: z.ZodString;
+    parameters: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, undefined, "queryGraph", unknown, false, undefined> & {
+    inputSchema: z.ZodObject<{
+        query: z.ZodString;
+        parameters: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    outputSchema: undefined;
+    approvalSchema: undefined;
+};

package/dist/src/lib/ai/tools/read-attachment.tool.d.ts

@@ -0,0 +1,21 @@
+import z from "zod";
+import type { ResolvedCortexAgentConfig } from "../../config";
+type ReadAttachmentToolOptions = {
+    db: ResolvedCortexAgentConfig["db"];
+    storage: NonNullable<ResolvedCortexAgentConfig["storage"]>;
+    vision: NonNullable<ResolvedCortexAgentConfig["vision"]>;
+    threadId: string;
+    userId: string;
+};
+export declare function createReadAttachmentTool(options: ReadAttachmentToolOptions): import("@tanstack/ai").ServerTool<z.ZodObject<{
+    attachmentId: z.ZodString;
+    query: z.ZodString;
+}, z.core.$strip>, undefined, "readAttachment", unknown, false, undefined> & {
+    inputSchema: z.ZodObject<{
+        attachmentId: z.ZodString;
+        query: z.ZodString;
+    }, z.core.$strip>;
+    outputSchema: undefined;
+    approvalSchema: undefined;
+};
+export {};

package/dist/src/lib/ai/tools/search-common.d.ts

@@ -0,0 +1,17 @@
+import z from "zod";
+import type { CcRuntime } from "../../cc/registry";
+/** The input shape all three catalog search tools share; only the query hint differs. */
+export declare function searchInputSchema(queryDescription: string): z.ZodObject<{
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/** The runtime search request those tools send: the model's input plus the turn's context. */
+export declare function searchRequest(cc: CcRuntime, input: {
+    query: string;
+    limit?: number;
+}): {
+    locale: "en" | "ar";
+    threadId: string;
+    query: string;
+    limit?: number;
+};

package/dist/src/lib/ai/tools/search-knowledge.tool.d.ts

@@ -0,0 +1,15 @@
+import z from "zod";
+import type { CcRuntime } from "../../cc/registry";
+export declare function createSearchKnowledgeTool(cc: CcRuntime): import("@tanstack/ai").ServerTool<z.ZodObject<{
+    query: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    service: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, undefined, "searchKnowledge", unknown, false, undefined> & {
+    inputSchema: z.ZodObject<{
+        query: z.ZodString;
+        limit: z.ZodOptional<z.ZodNumber>;
+        service: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    outputSchema: undefined;
+    approvalSchema: undefined;
+};

package/dist/src/lib/ai/tools/search-services.tool.d.ts

@@ -0,0 +1,12 @@
+import type { CcRuntime } from "../../cc/registry";
+export declare function createSearchServicesTool(cc: CcRuntime): import("@tanstack/ai").ServerTool<import("zod").ZodObject<{
+    query: import("zod").ZodString;
+    limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>, undefined, "searchServices", unknown, false, undefined> & {
+    inputSchema: import("zod").ZodObject<{
+        query: import("zod").ZodString;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>;
+    outputSchema: undefined;
+    approvalSchema: undefined;
+};

package/dist/src/lib/ai/tools/search-tools.tool.d.ts

@@ -0,0 +1,12 @@
+import type { CcRuntime } from "../../cc/registry";
+export declare function createSearchToolsTool(cc: CcRuntime): import("@tanstack/ai").ServerTool<import("zod").ZodObject<{
+    query: import("zod").ZodString;
+    limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>, undefined, "searchTools", unknown, false, undefined> & {
+    inputSchema: import("zod").ZodObject<{
+        query: import("zod").ZodString;
+        limit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>;
+    outputSchema: undefined;
+    approvalSchema: undefined;
+};

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

@@ -0,0 +1,39 @@
+import type { AnyServerTool } from "@tanstack/ai";
+import type { ResolvedCortexAgentConfig } from "../config";
+import type { Attachment, Thread } from "../types";
+import type { CcRuntime } from "../cc/registry";
+import type { Neo4jClient } from "../../../contracts/graph";
+type TurnToolsOptions = {
+    config: ResolvedCortexAgentConfig;
+    cc: CcRuntime | undefined;
+    neo4j: Neo4jClient | undefined;
+    thread: Thread;
+    userId: string;
+    token: string;
+    session: Record<string, unknown> | null;
+    requestContext: Record<string, unknown>;
+    threadAttachments: Attachment[];
+};
+/**
+ * Assembles the tool set for one turn: built-ins gated on what the agent has
+ * configured, then the agent's own tools.
+ *
+ * User tools are appended last and deliberately win on name collision — an agent
+ * must be able to replace a built-in it doesn't want.
+ */
+export declare function buildTurnTools(options: TurnToolsOptions): AnyServerTool[];
+/**
+ * Instruments tool calls for the callbacks an agent configured. Returns
+ * `undefined` when nothing is listening, so the caller can skip the middleware
+ * entirely.
+ */
+export declare function createToolInstrumentation(options: TurnToolsOptions & {
+    onToolStart: (toolName: string, toolCallId: string) => void;
+    onToolFinish: (toolName: string, toolCallId: string) => void;
+}): {
+    name: string;
+    onBeforeToolCall(_ctx: import("@tanstack/ai").ChatMiddlewareContext<unknown>, { toolName, toolCallId, args }: import("@tanstack/ai").ToolCallHookContext): void;
+    onAfterToolCall(_ctx: import("@tanstack/ai").ChatMiddlewareContext<unknown>, { toolName, toolCallId }: import("@tanstack/ai").AfterToolCallInfo): void;
+} | undefined;
+export declare function hasDefaultAttachmentInterceptor(config: ResolvedCortexAgentConfig): boolean;
+export {};

package/dist/src/lib/ai/vision/rasterize-pdf.d.ts

@@ -0,0 +1,26 @@
+export type RasterizedPdf = {
+    pages: {
+        data: Uint8Array;
+        width: number;
+        height: number;
+    }[];
+    totalPages: number;
+    truncatedBy?: "page-limit" | "payload-limit";
+};
+export type RasterizePdfWorkerRequest = {
+    bytes: Uint8Array;
+    maxPayloadBytes?: number;
+};
+export type RasterizePdfWorkerResponse = {
+    status: "success";
+    result: RasterizedPdf;
+} | {
+    status: "error";
+    message: string;
+};
+type RasterizePdfOptions = {
+    abortSignal?: AbortSignal;
+    maxPayloadBytes?: number;
+};
+export declare function rasterizePdf(bytes: Uint8Array, options?: RasterizePdfOptions): Promise<RasterizedPdf>;
+export {};

package/dist/src/lib/ai/vision/rasterize-pdf.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/lib/ai/vision/vision-reader.d.ts

@@ -0,0 +1,45 @@
+import type { ResolvedCortexAgentConfig } from "../../config";
+type VisionConfig = NonNullable<ResolvedCortexAgentConfig["vision"]>;
+export declare function describeAttachment(vision: VisionConfig, contentType: string, base64: string, abortSignal?: AbortSignal): Promise<{
+    status: "skipped";
+    error?: undefined;
+    text?: undefined;
+    note?: undefined;
+} | {
+    status: "failed";
+    error: string;
+    text?: undefined;
+    note?: undefined;
+} | {
+    status: "success";
+    text: string;
+    note: string;
+    error?: undefined;
+} | {
+    status: "failed";
+    error?: undefined;
+    text?: undefined;
+    note?: undefined;
+}>;
+export declare function answerQuestionAbout(vision: VisionConfig, contentType: string, base64: string, query: string, abortSignal?: AbortSignal): Promise<{
+    status: "skipped";
+    error?: undefined;
+    text?: undefined;
+    note?: undefined;
+} | {
+    status: "failed";
+    error: string;
+    text?: undefined;
+    note?: undefined;
+} | {
+    status: "success";
+    text: string;
+    note: string;
+    error?: undefined;
+} | {
+    status: "failed";
+    error?: undefined;
+    text?: undefined;
+    note?: undefined;
+}>;
+export {};