@revealui/ai 0.1.0

package/dist/client/hooks/useAgentEvents.js

@@ -0,0 +1,232 @@
+/**
+ * @revealui/ai - React Hooks for Observability
+ *
+ * React hooks for accessing and displaying agent events and metrics.
+ */
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { AgentEventQuery } from '../../observability/query.js';
+/**
+ * Hook for accessing agent events with real-time updates
+ */
+export function useAgentEvents(logger, filter, options) {
+    const [events, setEvents] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const refreshInterval = options?.refreshInterval ?? 5000;
+    const autoRefresh = options?.autoRefresh ?? true;
+    const refresh = useCallback(() => {
+        setLoading(true);
+        const newEvents = logger.getEvents(filter);
+        setEvents(newEvents);
+        setLoading(false);
+    }, [logger, filter]);
+    useEffect(() => {
+        refresh();
+        if (autoRefresh) {
+            const interval = setInterval(refresh, refreshInterval);
+            return () => clearInterval(interval);
+        }
+        return undefined;
+    }, [refresh, autoRefresh, refreshInterval]);
+    return {
+        events,
+        loading,
+        refresh,
+        count: events.length,
+    };
+}
+/**
+ * Hook for accessing agent metrics with real-time updates
+ */
+export function useAgentMetrics(collector, agentId, options) {
+    const [metrics, setMetrics] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const refreshInterval = options?.refreshInterval ?? 5000;
+    const autoRefresh = options?.autoRefresh ?? true;
+    const refresh = useCallback(() => {
+        setLoading(true);
+        const newMetrics = collector.getMetrics(agentId);
+        setMetrics(newMetrics);
+        setLoading(false);
+    }, [collector, agentId]);
+    useEffect(() => {
+        refresh();
+        if (autoRefresh) {
+            const interval = setInterval(refresh, refreshInterval);
+            return () => clearInterval(interval);
+        }
+        return undefined;
+    }, [refresh, autoRefresh, refreshInterval]);
+    return {
+        metrics,
+        loading,
+        refresh,
+    };
+}
+/**
+ * Hook for accessing metrics summary
+ */
+export function useMetricsSummary(collector, filter, options) {
+    const [summary, setSummary] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const refreshInterval = options?.refreshInterval ?? 5000;
+    const autoRefresh = options?.autoRefresh ?? true;
+    const refresh = useCallback(() => {
+        setLoading(true);
+        const newSummary = collector.getMetricsSummary(filter);
+        setSummary(newSummary);
+        setLoading(false);
+    }, [collector, filter]);
+    useEffect(() => {
+        refresh();
+        if (autoRefresh) {
+            const interval = setInterval(refresh, refreshInterval);
+            return () => clearInterval(interval);
+        }
+        return undefined;
+    }, [refresh, autoRefresh, refreshInterval]);
+    return {
+        summary,
+        loading,
+        refresh,
+    };
+}
+/**
+ * Hook for querying events with advanced filters
+ */
+export function useEventQuery(logger) {
+    const query = useMemo(() => new AgentEventQuery(logger), [logger]);
+    const getRecentEvents = useCallback((milliseconds, count) => {
+        return query.getRecentEvents(milliseconds, count);
+    }, [query]);
+    const getEventsForAgent = useCallback((agentId) => {
+        return query.getEventsForAgent(agentId);
+    }, [query]);
+    const getEventsForSession = useCallback((sessionId) => {
+        return query.getEventsForSession(sessionId);
+    }, [query]);
+    const searchEvents = useCallback((searchText, filter) => {
+        return query.searchEvents(searchText, filter);
+    }, [query]);
+    const paginateEvents = useCallback((page, pageSize, filter) => {
+        return query.paginateEvents(page, pageSize, filter);
+    }, [query]);
+    return {
+        query,
+        getRecentEvents,
+        getEventsForAgent,
+        getEventsForSession,
+        searchEvents,
+        paginateEvents,
+    };
+}
+/**
+ * Hook for tool usage statistics
+ */
+export function useToolUsageStats(collector, options) {
+    const [stats, setStats] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const refreshInterval = options?.refreshInterval ?? 5000;
+    const autoRefresh = options?.autoRefresh ?? true;
+    const refresh = useCallback(() => {
+        setLoading(true);
+        const newStats = collector.getToolUsageStats();
+        setStats(newStats);
+        setLoading(false);
+    }, [collector]);
+    useEffect(() => {
+        refresh();
+        if (autoRefresh) {
+            const interval = setInterval(refresh, refreshInterval);
+            return () => clearInterval(interval);
+        }
+        return undefined;
+    }, [refresh, autoRefresh, refreshInterval]);
+    return {
+        stats,
+        loading,
+        refresh,
+    };
+}
+/**
+ * Hook for LLM usage statistics
+ */
+export function useLLMUsageStats(collector, options) {
+    const [stats, setStats] = useState(null);
+    const [loading, setLoading] = useState(true);
+    const refreshInterval = options?.refreshInterval ?? 5000;
+    const autoRefresh = options?.autoRefresh ?? true;
+    const refresh = useCallback(() => {
+        setLoading(true);
+        const newStats = collector.getLLMUsageStats();
+        setStats(newStats);
+        setLoading(false);
+    }, [collector]);
+    useEffect(() => {
+        refresh();
+        if (autoRefresh) {
+            const interval = setInterval(refresh, refreshInterval);
+            return () => clearInterval(interval);
+        }
+        return undefined;
+    }, [refresh, autoRefresh, refreshInterval]);
+    return {
+        stats,
+        loading,
+        refresh,
+    };
+}
+/**
+ * Hook for real-time event stream
+ */
+export function useEventStream(logger, options) {
+    const [events, setEvents] = useState([]);
+    const maxEvents = options?.maxEvents ?? 100;
+    useEffect(() => {
+        const interval = setInterval(() => {
+            const newEvents = logger.getEvents(options?.filter);
+            setEvents(newEvents.slice(-maxEvents));
+        }, 1000); // Update every second
+        return () => clearInterval(interval);
+    }, [logger, maxEvents, options?.filter]);
+    return {
+        events,
+        latestEvent: events[events.length - 1],
+    };
+}
+/**
+ * Hook for paginated events
+ */
+export function usePaginatedEvents(logger, initialPageSize = 20, filter) {
+    const [page, setPage] = useState(1);
+    const [pageSize, setPageSize] = useState(initialPageSize);
+    const query = useMemo(() => new AgentEventQuery(logger), [logger]);
+    const result = useMemo(() => {
+        return query.paginateEvents(page, pageSize, filter);
+    }, [query, page, pageSize, filter]);
+    const nextPage = useCallback(() => {
+        if (page < result.totalPages) {
+            setPage(page + 1);
+        }
+    }, [page, result.totalPages]);
+    const prevPage = useCallback(() => {
+        if (page > 1) {
+            setPage(page - 1);
+        }
+    }, [page]);
+    const goToPage = useCallback((newPage) => {
+        setPage(Math.max(1, newPage));
+    }, []);
+    const changePageSize = useCallback((newSize) => {
+        setPageSize(newSize);
+        setPage(1); // Reset to first page
+    }, []);
+    return {
+        ...result,
+        nextPage,
+        prevPage,
+        goToPage,
+        changePageSize,
+        hasNextPage: page < result.totalPages,
+        hasPrevPage: page > 1,
+    };
+}

package/dist/client/hooks/useAgentStream.d.ts

@@ -0,0 +1,44 @@
+/**
+ * useAgentStream — React hook for streaming agent responses via SSE
+ *
+ * Uses fetch + ReadableStream (NOT EventSource — it doesn't support POST).
+ * Accumulates AgentStreamChunks into state and exposes:
+ *   - text: accumulated output text
+ *   - chunks: all received chunks in order
+ *   - isStreaming: true while the stream is open
+ *   - error: last error message, if any
+ *   - abort(): cancels the stream
+ */
+export interface AgentStreamChunk {
+    type: 'text' | 'tool_call_start' | 'tool_call_result' | 'error' | 'done';
+    content?: string;
+    toolCall?: {
+        name: string;
+        arguments: string;
+    };
+    toolResult?: unknown;
+    error?: string;
+    metadata?: {
+        tokensUsed?: number;
+        executionTime?: number;
+    };
+}
+export interface AgentStreamRequest {
+    instruction: string;
+    boardId?: string;
+    workspaceId?: string;
+    priority?: 'low' | 'medium' | 'high' | 'critical';
+}
+export interface UseAgentStreamState {
+    text: string;
+    chunks: AgentStreamChunk[];
+    isStreaming: boolean;
+    error: string | null;
+}
+export interface UseAgentStreamReturn extends UseAgentStreamState {
+    start: (request: AgentStreamRequest, apiBase?: string) => Promise<void>;
+    abort: () => void;
+    reset: () => void;
+}
+export declare function useAgentStream(): UseAgentStreamReturn;
+//# sourceMappingURL=useAgentStream.d.ts.map

package/dist/client/hooks/useAgentStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAgentStream.d.ts","sourceRoot":"","sources":["../../../src/client/hooks/useAgentStream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,GAAG,iBAAiB,GAAG,kBAAkB,GAAG,OAAO,GAAG,MAAM,CAAA;IACxE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,QAAQ,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAA;IAC9C,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAC3D;AAED,MAAM,WAAW,kBAAkB;IACjC,WAAW,EAAE,MAAM,CAAA;IACnB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAA;CAClD;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,gBAAgB,EAAE,CAAA;IAC1B,WAAW,EAAE,OAAO,CAAA;IACpB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CACrB;AAED,MAAM,WAAW,oBAAqB,SAAQ,mBAAmB;IAC/D,KAAK,EAAE,CAAC,OAAO,EAAE,kBAAkB,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACvE,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB;AASD,wBAAgB,cAAc,IAAI,oBAAoB,CA2FrD"}

package/dist/client/hooks/useAgentStream.js

@@ -0,0 +1,101 @@
+/**
+ * useAgentStream — React hook for streaming agent responses via SSE
+ *
+ * Uses fetch + ReadableStream (NOT EventSource — it doesn't support POST).
+ * Accumulates AgentStreamChunks into state and exposes:
+ *   - text: accumulated output text
+ *   - chunks: all received chunks in order
+ *   - isStreaming: true while the stream is open
+ *   - error: last error message, if any
+ *   - abort(): cancels the stream
+ */
+'use client';
+import { useCallback, useRef, useState } from 'react';
+const INITIAL_STATE = {
+    text: '',
+    chunks: [],
+    isStreaming: false,
+    error: null,
+};
+export function useAgentStream() {
+    const [state, setState] = useState(INITIAL_STATE);
+    const controllerRef = useRef(null);
+    const abort = useCallback(() => {
+        controllerRef.current?.abort();
+        setState((s) => ({ ...s, isStreaming: false }));
+    }, []);
+    const reset = useCallback(() => {
+        controllerRef.current?.abort();
+        setState(INITIAL_STATE);
+    }, []);
+    const start = useCallback(async (request, apiBase = '/api/agent-stream') => {
+        controllerRef.current?.abort();
+        const controller = new AbortController();
+        controllerRef.current = controller;
+        setState({ text: '', chunks: [], isStreaming: true, error: null });
+        try {
+            const response = await fetch(apiBase, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(request),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                const errText = await response.text();
+                setState((s) => ({
+                    ...s,
+                    isStreaming: false,
+                    error: `HTTP ${response.status}: ${errText}`,
+                }));
+                return;
+            }
+            if (!response.body) {
+                setState((s) => ({ ...s, isStreaming: false, error: 'No response body' }));
+                return;
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            while (true) {
+                const { value, done } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                // Parse SSE lines: "data: {...}\n\n"
+                const events = buffer.split('\n\n');
+                buffer = events.pop() ?? '';
+                for (const event of events) {
+                    const dataLine = event.split('\n').find((l) => l.startsWith('data: '));
+                    if (!dataLine)
+                        continue;
+                    const jsonStr = dataLine.slice(6);
+                    try {
+                        const chunk = JSON.parse(jsonStr);
+                        setState((s) => ({
+                            ...s,
+                            chunks: [...s.chunks, chunk],
+                            text: chunk.type === 'text' ? s.text + (chunk.content ?? '') : s.text,
+                            error: chunk.type === 'error' ? (chunk.error ?? 'Unknown error') : s.error,
+                            isStreaming: chunk.type !== 'done' && chunk.type !== 'error',
+                        }));
+                    }
+                    catch {
+                        // Malformed SSE data — skip
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'AbortError') {
+                setState((s) => ({ ...s, isStreaming: false }));
+                return;
+            }
+            setState((s) => ({
+                ...s,
+                isStreaming: false,
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        }
+    }, []);
+    return { ...state, start, abort, reset };
+}

package/dist/client/hooks/useEpisodicMemory.d.ts

@@ -0,0 +1,25 @@
+/**
+ * useEpisodicMemory Hook
+ *
+ * React hook for managing episodic memory in client components.
+ */
+import type { AgentMemory } from '@revealui/contracts/agents';
+export interface UseEpisodicMemoryReturn {
+    memories: AgentMemory[];
+    addMemory: (memory: AgentMemory) => Promise<string>;
+    removeMemory: (memoryId: string) => Promise<void>;
+    getMemory: (memoryId: string) => AgentMemory | undefined;
+    search: (query: string) => Promise<AgentMemory[]>;
+    accessCount: number;
+    isLoading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+/**
+ * React hook for episodic memory management.
+ *
+ * @param userId - User identifier
+ * @returns Episodic memory state and operations
+ */
+export declare function useEpisodicMemory(userId: string): UseEpisodicMemoryReturn;
+//# sourceMappingURL=useEpisodicMemory.d.ts.map

package/dist/client/hooks/useEpisodicMemory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEpisodicMemory.d.ts","sourceRoot":"","sources":["../../../src/client/hooks/useEpisodicMemory.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAO7D,MAAM,WAAW,uBAAuB;IACtC,QAAQ,EAAE,WAAW,EAAE,CAAA;IACvB,SAAS,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IACnD,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACjD,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,WAAW,GAAG,SAAS,CAAA;IACxD,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,WAAW,EAAE,CAAC,CAAA;IACjD,WAAW,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;IACnB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC7B;AAmCD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,uBAAuB,CA4KzE"}

package/dist/client/hooks/useEpisodicMemory.js

@@ -0,0 +1,174 @@
+/**
+ * useEpisodicMemory Hook
+ *
+ * React hook for managing episodic memory in client components.
+ */
+import { useCallback, useEffect, useState } from 'react';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const isAgentMemory = (value) => {
+    if (!isRecord(value))
+        return false;
+    return typeof value.id === 'string' && typeof value.content === 'string';
+};
+const parseEpisodicPayload = (payload) => {
+    if (!isRecord(payload)) {
+        return { memories: [], accessCount: 0 };
+    }
+    const memories = Array.isArray(payload.memories) ? payload.memories.filter(isAgentMemory) : [];
+    const accessCount = typeof payload.accessCount === 'number' ? payload.accessCount : 0;
+    const tag = typeof payload.tag === 'string' ? payload.tag : undefined;
+    const memoryId = typeof payload.memoryId === 'string' ? payload.memoryId : undefined;
+    return { memories, accessCount, tag, memoryId };
+};
+// =============================================================================
+// Hook
+// =============================================================================
+/**
+ * React hook for episodic memory management.
+ *
+ * @param userId - User identifier
+ * @returns Episodic memory state and operations
+ */
+export function useEpisodicMemory(userId) {
+    const [memories, setMemories] = useState([]);
+    const [accessCount, setAccessCount] = useState(0);
+    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/episodic/${userId}`);
+                if (!response.ok) {
+                    throw new Error(`Failed to load episodic memory: ${response.statusText}`);
+                }
+                const payload = (await response.json());
+                if (!mounted)
+                    return;
+                const parsed = parseEpisodicPayload(payload);
+                setMemories(parsed.memories);
+                setAccessCount(parsed.accessCount);
+            }
+            catch (err) {
+                if (!mounted)
+                    return;
+                setError(err instanceof Error ? err : new Error('Unknown error'));
+            }
+            finally {
+                if (mounted) {
+                    setIsLoading(false);
+                }
+            }
+        }
+        void load();
+        return () => {
+            mounted = false;
+        };
+    }, [userId]);
+    // Refresh function
+    const refresh = useCallback(async () => {
+        try {
+            setIsLoading(true);
+            setError(null);
+            const response = await fetch(`/api/memory/episodic/${userId}`);
+            if (!response.ok) {
+                throw new Error(`Failed to refresh episodic memory: ${response.statusText}`);
+            }
+            const payload = (await response.json());
+            const parsed = parseEpisodicPayload(payload);
+            setMemories(parsed.memories);
+            setAccessCount(parsed.accessCount);
+            setError(null);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error('Unknown error'));
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [userId]);
+    // Add memory
+    const addMemory = useCallback(async (memory) => {
+        try {
+            setError(null);
+            const response = await fetch(`/api/memory/episodic/${userId}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(memory),
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to add memory: ${response.statusText}`);
+            }
+            const payload = (await response.json());
+            const parsed = parseEpisodicPayload(payload);
+            // Refresh to get updated list
+            await refresh();
+            return parsed.tag ?? parsed.memoryId ?? memory.id;
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error('Unknown error'));
+            throw err;
+        }
+    }, [userId, refresh]);
+    // Remove memory
+    const removeMemory = useCallback(async (memoryId) => {
+        try {
+            setError(null);
+            const response = await fetch(`/api/memory/episodic/${userId}/${memoryId}`, {
+                method: 'DELETE',
+            });
+            if (!response.ok) {
+                throw new Error(`Failed to remove memory: ${response.statusText}`);
+            }
+            // Refresh to get updated list
+            await refresh();
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error('Unknown error'));
+            throw err;
+        }
+    }, [userId, refresh]);
+    // Get memory
+    const getMemory = useCallback((memoryId) => {
+        return memories.find((m) => m.id === memoryId);
+    }, [memories]);
+    // Search using vector similarity via API
+    const search = useCallback(async (query) => {
+        try {
+            const response = await fetch('/api/memory/search-text', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ query, options: { limit: 20, threshold: 0.5 } }),
+            });
+            if (!response.ok) {
+                throw new Error(`Search failed: ${response.statusText}`);
+            }
+            const data = (await response.json());
+            if (data.results && Array.isArray(data.results)) {
+                return data.results.map((r) => r.memory);
+            }
+            // Fallback to client-side filter if API returns unexpected format
+            const lowerQuery = query.toLowerCase();
+            return memories.filter((m) => m.content.toLowerCase().includes(lowerQuery));
+        }
+        catch {
+            // Fallback to client-side text filter on error
+            const lowerQuery = query.toLowerCase();
+            return memories.filter((m) => m.content.toLowerCase().includes(lowerQuery));
+        }
+    }, [memories]);
+    return {
+        memories,
+        addMemory,
+        removeMemory,
+        getMemory,
+        search,
+        accessCount,
+        isLoading,
+        error,
+        refresh,
+    };
+}

package/dist/client/hooks/useWorkingMemory.d.ts

@@ -0,0 +1,57 @@
+/**
+ * useWorkingMemory Hook
+ *
+ * React hook for managing working memory in client components.
+ */
+export interface UseWorkingMemoryOptions {
+    autoSync?: boolean;
+    syncInterval?: number;
+}
+export interface UseWorkingMemoryReturn {
+    context: Record<string, unknown>;
+    setContext: (context: Record<string, unknown>) => Promise<void>;
+    updateContext: (updates: Partial<Record<string, unknown>>) => Promise<void>;
+    getContextValue: (key: string) => unknown;
+    setContextValue: (key: string, value: unknown) => Promise<void>;
+    sessionState: {
+        status: 'active' | 'paused' | 'completed';
+        focus?: {
+            siteId?: string;
+            pageId?: string;
+            blockId?: string;
+            selection?: string[];
+        };
+        currentTask?: {
+            id: string;
+            description: string;
+            status: 'pending' | 'running' | 'completed' | 'failed';
+            progress?: number;
+        };
+    };
+    updateSessionState: (state: Partial<UseWorkingMemoryReturn['sessionState']>) => Promise<void>;
+    activeAgents: Array<{
+        id: string;
+        name: string;
+        description: string;
+        model: string;
+        systemPrompt: string;
+        tools: unknown[];
+        capabilities: string[];
+        temperature: number;
+        maxTokens: number;
+    }>;
+    addAgent: (agent: UseWorkingMemoryReturn['activeAgents'][0]) => Promise<void>;
+    removeAgent: (agentId: string) => Promise<void>;
+    isLoading: boolean;
+    error: Error | null;
+    sync: () => Promise<void>;
+}
+/**
+ * React hook for working memory management.
+ *
+ * @param sessionId - Session identifier
+ * @param options - Hook options
+ * @returns Working memory state and operations
+ */
+export declare function useWorkingMemory(sessionId: string, options?: UseWorkingMemoryOptions): UseWorkingMemoryReturn;
+//# sourceMappingURL=useWorkingMemory.d.ts.map

package/dist/client/hooks/useWorkingMemory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWorkingMemory.d.ts","sourceRoot":"","sources":["../../../src/client/hooks/useWorkingMemory.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAChC,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC/D,aAAa,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC3E,eAAe,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAA;IACzC,eAAe,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC/D,YAAY,EAAE;QACZ,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,WAAW,CAAA;QACzC,KAAK,CAAC,EAAE;YACN,MAAM,CAAC,EAAE,MAAM,CAAA;YACf,MAAM,CAAC,EAAE,MAAM,CAAA;YACf,OAAO,CAAC,EAAE,MAAM,CAAA;YAChB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAA;SACrB,CAAA;QACD,WAAW,CAAC,EAAE;YACZ,EAAE,EAAE,MAAM,CAAA;YACV,WAAW,EAAE,MAAM,CAAA;YACnB,MAAM,EAAE,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAA;YACtD,QAAQ,CAAC,EAAE,MAAM,CAAA;SAClB,CAAA;KACF,CAAA;IACD,kBAAkB,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,sBAAsB,CAAC,cAAc,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC7F,YAAY,EAAE,KAAK,CAAC;QAClB,EAAE,EAAE,MAAM,CAAA;QACV,IAAI,EAAE,MAAM,CAAA;QACZ,WAAW,EAAE,MAAM,CAAA;QACnB,KAAK,EAAE,MAAM,CAAA;QACb,YAAY,EAAE,MAAM,CAAA;QACpB,KAAK,EAAE,OAAO,EAAE,CAAA;QAChB,YAAY,EAAE,MAAM,EAAE,CAAA;QACtB,WAAW,EAAE,MAAM,CAAA;QACnB,SAAS,EAAE,MAAM,CAAA;KAClB,CAAC,CAAA;IACF,QAAQ,EAAE,CAAC,KAAK,EAAE,sBAAsB,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC7E,WAAW,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC/C,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;IACnB,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1B;AAiHD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,uBAA4B,GACpC,sBAAsB,CA6NxB"}