@revealui/ai 0.1.0

package/dist/client/hooks/useWorkingMemory.js

@@ -0,0 +1,276 @@
+/**
+ * useWorkingMemory Hook
+ *
+ * React hook for managing working memory in client components.
+ */
+import { useCallback, useEffect, useState } from 'react';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isSessionStatus = (value) => value === 'active' || value === 'paused' || value === 'completed';
+const isTaskStatus = (value) => value === 'pending' || value === 'running' || value === 'completed' || value === 'failed';
+const isActiveAgent = (value) => {
+    if (!isRecord(value))
+        return false;
+    return (typeof value.id === 'string' &&
+        typeof value.name === 'string' &&
+        typeof value.description === 'string' &&
+        typeof value.model === 'string' &&
+        typeof value.systemPrompt === 'string' &&
+        Array.isArray(value.tools) &&
+        Array.isArray(value.capabilities) &&
+        value.capabilities.every((capability) => typeof capability === 'string') &&
+        typeof value.temperature === 'number' &&
+        typeof value.maxTokens === 'number');
+};
+const parseSessionState = (value) => {
+    if (!isRecord(value)) {
+        return { status: 'active' };
+    }
+    const status = isSessionStatus(value.status) ? value.status : 'active';
+    const sessionState = { status };
+    if (isRecord(value.focus)) {
+        const focusValue = value.focus;
+        const selection = Array.isArray(focusValue.selection)
+            ? focusValue.selection.filter((item) => typeof item === 'string')
+            : undefined;
+        const focus = {
+            siteId: typeof focusValue.siteId === 'string' ? focusValue.siteId : undefined,
+            pageId: typeof focusValue.pageId === 'string' ? focusValue.pageId : undefined,
+            blockId: typeof focusValue.blockId === 'string' ? focusValue.blockId : undefined,
+            selection: selection && selection.length > 0 ? selection : undefined,
+        };
+        if (focus.siteId || focus.pageId || focus.blockId || focus.selection) {
+            sessionState.focus = focus;
+        }
+    }
+    if (isRecord(value.currentTask)) {
+        const taskValue = value.currentTask;
+        const id = typeof taskValue.id === 'string' ? taskValue.id : undefined;
+        const description = typeof taskValue.description === 'string' ? taskValue.description : undefined;
+        let taskStatus;
+        if (isTaskStatus(taskValue.status)) {
+            taskStatus = taskValue.status;
+        }
+        const progress = typeof taskValue.progress === 'number' ? taskValue.progress : undefined;
+        if (id && description && taskStatus) {
+            sessionState.currentTask = {
+                id,
+                description,
+                status: taskStatus,
+                progress,
+            };
+        }
+    }
+    return sessionState;
+};
+const parseContextPayload = (payload) => {
+    if (!isRecord(payload))
+        return {};
+    return isRecord(payload.context) ? payload.context : {};
+};
+const parseSessionPayload = (payload) => {
+    if (!isRecord(payload))
+        return { status: 'active' };
+    return parseSessionState(payload.sessionState);
+};
+const parseActiveAgentsPayload = (payload) => {
+    if (!isRecord(payload))
+        return [];
+    return Array.isArray(payload.activeAgents) ? payload.activeAgents.filter(isActiveAgent) : [];
+};
+const parseWorkingPayload = (payload) => ({
+    context: parseContextPayload(payload),
+    sessionState: parseSessionPayload(payload),
+    activeAgents: parseActiveAgentsPayload(payload),
+});
+// =============================================================================
+// Hook
+// =============================================================================
+/**
+ * React hook for working memory management.
+ *
+ * @param sessionId - Session identifier
+ * @param options - Hook options
+ * @returns Working memory state and operations
+ */
+export function useWorkingMemory(sessionId, options = {}) {
+    const { autoSync = false, syncInterval = 5000 } = options;
+    const [context, setContextState] = useState({});
+    const [sessionState, setSessionStateState] = useState({
+        status: 'active',
+    });
+    const [activeAgents, setActiveAgents] = useState([]);
+    const [isLoading, setIsLoading] = useState(true);
+    const [error, setError] = useState(null);
+    // Load initial state
+    useEffect(() => {
+        let mounted = true;
+        async function load() {
+            try {
+                setIsLoading(true);
+                setError(null);
+                const response = await fetch(`/api/memory/working/${sessionId}`);
+                if (!response.ok) {
+                    throw new Error(`Failed to load working memory: ${response.statusText}`);
+                }
+                const payload = (await response.json());
+                if (!mounted)
+                    return;
+                const parsed = parseWorkingPayload(payload);
+                setContextState(parsed.context);
+                setSessionStateState(parsed.sessionState);
+                setActiveAgents(parsed.activeAgents);
+            }
+            catch (err) {
+                if (!mounted)
+                    return;
+                setError(err instanceof Error ? err : new Error('Unknown error'));
+            }
+            finally {
+                if (mounted) {
+                    setIsLoading(false);
+                }
+            }
+        }
+        void load();
+        return () => {
+            mounted = false;
+        };
+    }, [sessionId]);
+    // Sync function
+    const sync = useCallback(async () => {
+        try {
+            const response = await fetch(`/api/memory/working/${sessionId}`);
+            if (!response.ok) {
+                throw new Error(`Failed to sync working memory: ${response.statusText}`);
+            }
+            const payload = (await response.json());
+            const parsed = parseWorkingPayload(payload);
+            setContextState(parsed.context);
+            setSessionStateState(parsed.sessionState);
+            setActiveAgents(parsed.activeAgents);
+            setError(null);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error('Unknown error'));
+        }
+    }, [sessionId]);
+    // Auto-sync
+    useEffect(() => {
+        if (!autoSync)
+            return;
+        const interval = setInterval(() => {
+            void sync();
+        }, syncInterval);
+        return () => clearInterval(interval);
+    }, [autoSync, syncInterval, sync]);
+    // Set context
+    const setContext = useCallback(async (newContext) => {
+        try {
+            setError(null);
+            const response = await fetch(`/api/memory/working/${sessionId}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ context: newContext }),
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to update context: ${response.statusText}`);
+            }
+            const payload = (await response.json());
+            setContextState(parseContextPayload(payload));
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error('Unknown error'));
+            throw err;
+        }
+    }, [sessionId]);
+    // Update context
+    const updateContext = useCallback(async (updates) => {
+        const newContext = { ...context, ...updates };
+        await setContext(newContext);
+    }, [context, setContext]);
+    // Get context value
+    const getContextValue = useCallback((key) => {
+        return context[key];
+    }, [context]);
+    // Set context value
+    const setContextValue = useCallback(async (key, value) => {
+        await updateContext({ [key]: value });
+    }, [updateContext]);
+    // Update session state
+    const updateSessionState = useCallback(async (state) => {
+        try {
+            setError(null);
+            const response = await fetch(`/api/memory/working/${sessionId}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ sessionState: state }),
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to update session state: ${response.statusText}`);
+            }
+            const payload = (await response.json());
+            setSessionStateState(parseSessionPayload(payload));
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error('Unknown error'));
+            throw err;
+        }
+    }, [sessionId]);
+    // Add agent
+    const addAgent = useCallback(async (agent) => {
+        try {
+            setError(null);
+            const newAgents = [...activeAgents, agent];
+            const response = await fetch(`/api/memory/working/${sessionId}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ activeAgents: newAgents }),
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to add agent: ${response.statusText}`);
+            }
+            const payload = (await response.json());
+            setActiveAgents(parseActiveAgentsPayload(payload));
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error('Unknown error'));
+            throw err;
+        }
+    }, [sessionId, activeAgents]);
+    // Remove agent
+    const removeAgent = useCallback(async (agentId) => {
+        try {
+            setError(null);
+            const newAgents = activeAgents.filter((agent) => agent.id !== agentId);
+            const response = await fetch(`/api/memory/working/${sessionId}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ activeAgents: newAgents }),
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to remove agent: ${response.statusText}`);
+            }
+            const payload = (await response.json());
+            setActiveAgents(parseActiveAgentsPayload(payload));
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error('Unknown error'));
+            throw err;
+        }
+    }, [sessionId, activeAgents]);
+    return {
+        context,
+        setContext,
+        updateContext,
+        getContextValue,
+        setContextValue,
+        sessionState,
+        updateSessionState,
+        activeAgents,
+        addAgent,
+        removeAgent,
+        isLoading,
+        error,
+        sync,
+    };
+}

package/dist/client/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @revealui/ai/client - Client-side AI System
+ *
+ * React Hooks for AI System - Client-side integration:
+ * - useMemory: CRUD operations for memory
+ * - useAgentConfig: Agent configuration management
+ * - useVectorSearch: Semantic search queries
+ *
+ * These are client-side React hooks for use in browser environments.
+ *
+ * @packageDocumentation
+ */
+export * from './hooks/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,cAAc,kBAAkB,CAAA"}

package/dist/client/index.js

@@ -0,0 +1,13 @@
+/**
+ * @revealui/ai/client - Client-side AI System
+ *
+ * React Hooks for AI System - Client-side integration:
+ * - useMemory: CRUD operations for memory
+ * - useAgentConfig: Agent configuration management
+ * - useVectorSearch: Semantic search queries
+ *
+ * These are client-side React hooks for use in browser environments.
+ *
+ * @packageDocumentation
+ */
+export * from './hooks/index.js';

package/dist/embeddings/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Embedding Generation Utilities
+ *
+ * Functions for generating embeddings using the configured LLM provider.
+ * Provider is auto-detected from env vars (OLLAMA_BASE_URL → GROQ → ANTHROPIC).
+ * For local/free inference use Ollama with `nomic-embed-text`.
+ * Note: Groq and Anthropic do not support embeddings — use Ollama for embedding tasks.
+ */
+import z from 'zod/v4';
+declare const EmbeddingSchema: z.ZodObject<{
+    model: z.ZodString;
+    vector: z.ZodArray<z.ZodNumber>;
+    dimension: z.ZodNumber;
+    generatedAt: z.ZodString;
+}, z.core.$strip>;
+type Embedding = z.infer<typeof EmbeddingSchema>;
+export interface GenerateEmbeddingOptions {
+    /**
+     * Embedding model to use. Provider-specific:
+     * - Ollama: 'nomic-embed-text' (default), 'mxbai-embed-large', etc.
+     * - OpenAI: 'text-embedding-3-small', 'text-embedding-3-large', 'text-embedding-ada-002'
+     * If omitted, the provider uses its own default (Ollama → nomic-embed-text).
+     */
+    model?: string;
+    cache?: boolean;
+}
+/**
+ * Generate an embedding for the given text using the configured LLM provider.
+ *
+ * @param text - Text to generate embedding for
+ * @param options - Options for embedding generation
+ * @returns Embedding object with vector and metadata
+ *
+ * @example
+ * ```typescript
+ * // With Ollama (OLLAMA_BASE_URL set):
+ * const embedding = await generateEmbedding('user prefers dark theme')
+ * // Returns: { vector: number[], model: 'nomic-embed-text', dimension: 768, generatedAt: '...' }
+ * ```
+ */
+export declare function generateEmbedding(text: string, options?: GenerateEmbeddingOptions): Promise<Embedding>;
+/**
+ * Generate embeddings for multiple texts in batch.
+ *
+ * @param texts - Array of texts to generate embeddings for
+ * @param options - Options for embedding generation
+ * @returns Array of embeddings in the same order as input texts
+ */
+export declare function generateEmbeddings(texts: string[], options?: GenerateEmbeddingOptions): Promise<Embedding[]>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/embeddings/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/embeddings/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,CAAC,MAAM,QAAQ,CAAA;AAGtB,QAAA,MAAM,eAAe;;;;;iBAgBjB,CAAA;AACJ,KAAK,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEhD,MAAM,WAAW,wBAAwB;IACvC;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,OAAO,CAAA;CAChB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,SAAS,CAAC,CA4BpB;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,MAAM,EAAE,EACf,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,SAAS,EAAE,CAAC,CAMtB"}

package/dist/embeddings/index.js

@@ -0,0 +1,73 @@
+/**
+ * Embedding Generation Utilities
+ *
+ * Functions for generating embeddings using the configured LLM provider.
+ * Provider is auto-detected from env vars (OLLAMA_BASE_URL → GROQ → ANTHROPIC).
+ * For local/free inference use Ollama with `nomic-embed-text`.
+ * Note: Groq and Anthropic do not support embeddings — use Ollama for embedding tasks.
+ */
+import z from 'zod/v4';
+import { createLLMClientFromEnv } from '../llm/client.js';
+const EmbeddingSchema = z
+    .object({
+    /** The embedding model used */
+    model: z.string(),
+    /** The embedding vector */
+    vector: z.array(z.number()),
+    /** Dimension of the vector (for validation) */
+    dimension: z.number().int().positive(),
+    /** When this embedding was generated */
+    generatedAt: z.string().datetime(),
+})
+    .refine((data) => data.vector.length === data.dimension, {
+    message: 'Embedding vector length must match specified dimension',
+});
+/**
+ * Generate an embedding for the given text using the configured LLM provider.
+ *
+ * @param text - Text to generate embedding for
+ * @param options - Options for embedding generation
+ * @returns Embedding object with vector and metadata
+ *
+ * @example
+ * ```typescript
+ * // With Ollama (OLLAMA_BASE_URL set):
+ * const embedding = await generateEmbedding('user prefers dark theme')
+ * // Returns: { vector: number[], model: 'nomic-embed-text', dimension: 768, generatedAt: '...' }
+ * ```
+ */
+export async function generateEmbedding(text, options = {}) {
+    const { model } = options;
+    if (!text || typeof text !== 'string' || text.trim().length === 0) {
+        throw new Error('Text must be a non-empty string');
+    }
+    // Use unified LLM client — auto-detects provider from env vars
+    const client = createLLMClientFromEnv();
+    // Ask client to embed — each provider uses its own default model when model is undefined
+    const result = await client.embed(text, model ? { model } : undefined);
+    // If provider returned batch, pick first
+    const embeddingResult = Array.isArray(result) ? result[0] : result;
+    if (!(embeddingResult && Array.isArray(embeddingResult.vector))) {
+        throw new Error('Invalid embedding response from LLM provider');
+    }
+    const embedding = {
+        vector: embeddingResult.vector,
+        model: String(embeddingResult.model || model),
+        dimension: embeddingResult.dimension || embeddingResult.vector.length,
+        generatedAt: new Date().toISOString(),
+    };
+    return embedding;
+}
+/**
+ * Generate embeddings for multiple texts in batch.
+ *
+ * @param texts - Array of texts to generate embeddings for
+ * @param options - Options for embedding generation
+ * @returns Array of embeddings in the same order as input texts
+ */
+export async function generateEmbeddings(texts, options = {}) {
+    // Generate in parallel — providers that support batch (Ollama, OpenAI) can be
+    // optimised later by passing the full array directly to client.embed()
+    const embeddings = await Promise.all(texts.map((text) => generateEmbedding(text, options)));
+    return embeddings;
+}

package/dist/index.d.ts

@@ -0,0 +1,83 @@
+/**
+ * @revealui/ai - AI System for RevealUI
+ *
+ * A comprehensive AI system that provides:
+ * - Memory management (Working, Episodic, Semantic)
+ * - LLM provider abstractions (OpenAI, Anthropic, etc.)
+ * - Agent orchestration and execution
+ * - Tool calling system
+ * - Vector similarity search
+ * - CRDT-based persistent state
+ *
+ * ## Quick Start
+ *
+ * ```typescript
+ * import { EpisodicMemory } from '@revealui/ai/memory/stores'
+ * import { NodeIdService } from '@revealui/ai/memory/services'
+ *
+ * // Memory operations
+ * const memory = new EpisodicMemory(userId, nodeId, db)
+ * await memory.add(agentMemory)
+ *
+ * // LLM, orchestration, and tools coming soon
+ * ```
+ *
+ * ## Architecture
+ *
+ * ```
+ * ┌─────────────────────────────────────┐
+ * │  React Hooks (useMemory, etc.)      │
+ * ├─────────────────────────────────────┤
+ * │  AI System                          │
+ * │  ├── Memory (Working, Episodic)    │
+ * │  ├── LLM (Providers, Client)        │
+ * │  ├── Orchestration (Agents)        │
+ * │  ├── Tools (Registry, Executor)    │
+ * │  └── Skills (Agent Skills)         │
+ * ├─────────────────────────────────────┤
+ * │  CRDT Core (LWW, OR-Set, Counter)  │
+ * ├─────────────────────────────────────┤
+ * │  Vector Search (pgvector)          │
+ * ├─────────────────────────────────────┤
+ * │  Persistence (Drizzle/NeonDB)      │
+ * └─────────────────────────────────────┘
+ * ```
+ *
+ * @packageDocumentation
+ */
+/**
+ * Check if the AI package is licensed for use.
+ * Returns false with a warning log if no Pro/Enterprise license is active.
+ * Call at application startup to verify licensing.
+ */
+export declare function checkAiLicense(): boolean;
+export * from './a2a/index.js';
+export * from './audit/index.js';
+export * from './embeddings/index.js';
+export * from './ingestion/index.js';
+export * from './llm/client.js';
+export * from './llm/provider-health.js';
+export * from './llm/providers/anthropic.js';
+export * from './llm/providers/base.js';
+export * from './llm/providers/openai.js';
+export * from './llm/token-counter.js';
+export * from './llm/workspace-provider-config.js';
+export * from './memory/index.js';
+export * from './orchestration/agent.js';
+export * from './orchestration/defaults.js';
+export * from './orchestration/memory-integration.js';
+export * from './orchestration/orchestrator.js';
+export * from './orchestration/runtime.js';
+export * from './orchestration/streaming-runtime.js';
+export * from './orchestration/ticket-agent.js';
+export * from './skills/index.js';
+export * from './templates/index.js';
+export * from './tools/base.js';
+export * from './tools/deduplicator.js';
+export * from './tools/document-summarizer.js';
+export * from './tools/mcp-adapter.js';
+export * from './tools/memory/index.js';
+export * from './tools/registry.js';
+export * from './tools/ticket-tools.js';
+export * from './tools/web/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAKH;;;;GAIG;AACH,wBAAgB,cAAc,IAAI,OAAO,CASxC;AAGD,cAAc,gBAAgB,CAAA;AAE9B,cAAc,kBAAkB,CAAA;AAIhC,cAAc,uBAAuB,CAAA;AAErC,cAAc,sBAAsB,CAAA;AAEpC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,0BAA0B,CAAA;AACxC,cAAc,8BAA8B,CAAA;AAC5C,cAAc,yBAAyB,CAAA;AACvC,cAAc,2BAA2B,CAAA;AACzC,cAAc,wBAAwB,CAAA;AACtC,cAAc,oCAAoC,CAAA;AAElD,cAAc,mBAAmB,CAAA;AAEjC,cAAc,0BAA0B,CAAA;AACxC,cAAc,6BAA6B,CAAA;AAC3C,cAAc,uCAAuC,CAAA;AACrD,cAAc,iCAAiC,CAAA;AAC/C,cAAc,4BAA4B,CAAA;AAC1C,cAAc,sCAAsC,CAAA;AACpD,cAAc,iCAAiC,CAAA;AAE/C,cAAc,mBAAmB,CAAA;AAEjC,cAAc,sBAAsB,CAAA;AAEpC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,yBAAyB,CAAA;AACvC,cAAc,gCAAgC,CAAA;AAC9C,cAAc,wBAAwB,CAAA;AACtC,cAAc,yBAAyB,CAAA;AACvC,cAAc,qBAAqB,CAAA;AACnC,cAAc,yBAAyB,CAAA;AACvC,cAAc,sBAAsB,CAAA"}

package/dist/index.js

@@ -0,0 +1,103 @@
+/**
+ * @revealui/ai - AI System for RevealUI
+ *
+ * A comprehensive AI system that provides:
+ * - Memory management (Working, Episodic, Semantic)
+ * - LLM provider abstractions (OpenAI, Anthropic, etc.)
+ * - Agent orchestration and execution
+ * - Tool calling system
+ * - Vector similarity search
+ * - CRDT-based persistent state
+ *
+ * ## Quick Start
+ *
+ * ```typescript
+ * import { EpisodicMemory } from '@revealui/ai/memory/stores'
+ * import { NodeIdService } from '@revealui/ai/memory/services'
+ *
+ * // Memory operations
+ * const memory = new EpisodicMemory(userId, nodeId, db)
+ * await memory.add(agentMemory)
+ *
+ * // LLM, orchestration, and tools coming soon
+ * ```
+ *
+ * ## Architecture
+ *
+ * ```
+ * ┌─────────────────────────────────────┐
+ * │  React Hooks (useMemory, etc.)      │
+ * ├─────────────────────────────────────┤
+ * │  AI System                          │
+ * │  ├── Memory (Working, Episodic)    │
+ * │  ├── LLM (Providers, Client)        │
+ * │  ├── Orchestration (Agents)        │
+ * │  ├── Tools (Registry, Executor)    │
+ * │  └── Skills (Agent Skills)         │
+ * ├─────────────────────────────────────┤
+ * │  CRDT Core (LWW, OR-Set, Counter)  │
+ * ├─────────────────────────────────────┤
+ * │  Vector Search (pgvector)          │
+ * ├─────────────────────────────────────┤
+ * │  Persistence (Drizzle/NeonDB)      │
+ * └─────────────────────────────────────┘
+ * ```
+ *
+ * @packageDocumentation
+ */
+import { isFeatureEnabled } from '@revealui/core/features';
+import { logger } from '@revealui/core/observability/logger';
+/**
+ * Check if the AI package is licensed for use.
+ * Returns false with a warning log if no Pro/Enterprise license is active.
+ * Call at application startup to verify licensing.
+ */
+export function checkAiLicense() {
+    if (!isFeatureEnabled('ai')) {
+        logger.warn('[@revealui/ai] AI features require a Pro or Enterprise license. ' +
+            'Visit https://revealui.com/pricing for details.');
+        return false;
+    }
+    return true;
+}
+// Re-export A2A protocol
+export * from './a2a/index.js';
+// Re-export audit trail
+export * from './audit/index.js';
+// Client-side React hooks are intentionally NOT re-exported here.
+// This main entry is server-safe. Use @revealui/ai/client for React hooks.
+// Re-export embeddings
+export * from './embeddings/index.js';
+// Re-export ingestion pipeline (RAG document indexing + hybrid search)
+export * from './ingestion/index.js';
+// Re-export LLM providers and client
+export * from './llm/client.js';
+export * from './llm/provider-health.js';
+export * from './llm/providers/anthropic.js';
+export * from './llm/providers/base.js';
+export * from './llm/providers/openai.js';
+export * from './llm/token-counter.js';
+export * from './llm/workspace-provider-config.js';
+// Re-export memory system
+export * from './memory/index.js';
+// Re-export orchestration
+export * from './orchestration/agent.js';
+export * from './orchestration/defaults.js';
+export * from './orchestration/memory-integration.js';
+export * from './orchestration/orchestrator.js';
+export * from './orchestration/runtime.js';
+export * from './orchestration/streaming-runtime.js';
+export * from './orchestration/ticket-agent.js';
+// Re-export skills
+export * from './skills/index.js';
+// Re-export specification templates
+export * from './templates/index.js';
+// Re-export tools
+export * from './tools/base.js';
+export * from './tools/deduplicator.js';
+export * from './tools/document-summarizer.js';
+export * from './tools/mcp-adapter.js';
+export * from './tools/memory/index.js';
+export * from './tools/registry.js';
+export * from './tools/ticket-tools.js';
+export * from './tools/web/index.js';

package/dist/inference/context-assembly.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Context Assembly with Smart Trimming
+ *
+ * Blends relevance (cosine similarity) and recency (createdAt) to rank chunks,
+ * then greedily assembles them up to a token budget.
+ * Auto-compresses single chunks that exceed half the budget.
+ *
+ * AnythingLLM lesson: plain cosine-only retrieval without recency weighting
+ * produces stale, misleading context in long-running knowledge bases.
+ */
+import type { RagSearchResult } from '../ingestion/rag-vector-service.js';
+export interface AssembleContextOptions {
+    /** Maximum token budget for the assembled context */
+    maxTokens: number;
+    /** Weight for recency score (default 0.3) */
+    recencyWeight?: number;
+    /** Weight for cosine similarity (default 0.7) */
+    relevanceWeight?: number;
+}
+/**
+ * Assemble RAG context from search results.
+ *
+ * Returns a formatted string of numbered references, trimmed to maxTokens.
+ * Returns '' if results is empty.
+ */
+export declare function assembleContext(results: RagSearchResult[], options: AssembleContextOptions): string;
+//# sourceMappingURL=context-assembly.d.ts.map

package/dist/inference/context-assembly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-assembly.d.ts","sourceRoot":"","sources":["../../src/inference/context-assembly.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oCAAoC,CAAA;AAEzE,MAAM,WAAW,sBAAsB;IACrC,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAA;IACjB,6CAA6C;IAC7C,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,iDAAiD;IACjD,eAAe,CAAC,EAAE,MAAM,CAAA;CACzB;AA+BD;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,eAAe,EAAE,EAC1B,OAAO,EAAE,sBAAsB,GAC9B,MAAM,CAiDR"}