lemma-sdk 0.2.28 → 0.2.31

package/dist/react/useAgentRuns.js

@@ -0,0 +1,149 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
+export function useAgentRuns({ client, podId, agentName, enabled = true, autoLoad = true, limit = 100, pageToken, initialTaskId = null, }) {
+    const [runs, setRuns] = useState([]);
+    const [total, setTotal] = useState(0);
+    const [nextPageToken, setNextPageToken] = useState(null);
+    const [selectedTaskId, setSelectedTaskId] = useState(initialTaskId);
+    const [isLoading, setIsLoading] = useState(false);
+    const [isLoadingMore, setIsLoadingMore] = useState(false);
+    const [error, setError] = useState(null);
+    const refresh = useCallback(async (overrides = {}, signal) => {
+        if (!enabled) {
+            setRuns([]);
+            setTotal(0);
+            setNextPageToken(null);
+            setError(null);
+            setIsLoading(false);
+            return [];
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const response = await scopedClient.tasks.list({
+                agent_name: agentName,
+                limit: overrides.limit ?? limit,
+                page_token: overrides.pageToken ?? pageToken,
+            });
+            if (signal?.aborted)
+                return [];
+            const nextRuns = response.items ?? [];
+            setRuns(nextRuns);
+            setTotal(response.total ?? nextRuns.length);
+            setNextPageToken(response.next_page_token ?? null);
+            setSelectedTaskId((current) => (current && nextRuns.some((run) => run.id === current) ? current : initialTaskId));
+            return nextRuns;
+        }
+        catch (refreshError) {
+            if (signal?.aborted)
+                return [];
+            const normalized = normalizeError(refreshError, "Failed to load agent runs.");
+            setError(normalized);
+            return [];
+        }
+        finally {
+            if (!signal?.aborted)
+                setIsLoading(false);
+        }
+    }, [agentName, client, enabled, initialTaskId, limit, pageToken, podId]);
+    const loadMore = useCallback(async (overrides = {}) => {
+        if (!enabled || !nextPageToken || isLoading || isLoadingMore) {
+            return [];
+        }
+        setIsLoadingMore(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const response = await scopedClient.tasks.list({
+                agent_name: agentName,
+                limit: overrides.limit ?? limit,
+                page_token: nextPageToken,
+            });
+            const moreRuns = response.items ?? [];
+            setRuns((previous) => [...previous, ...moreRuns]);
+            setTotal(response.total ?? runs.length + moreRuns.length);
+            setNextPageToken(response.next_page_token ?? null);
+            return moreRuns;
+        }
+        catch (loadError) {
+            const normalized = normalizeError(loadError, "Failed to load more agent runs.");
+            setError(normalized);
+            return [];
+        }
+        finally {
+            setIsLoadingMore(false);
+        }
+    }, [agentName, client, enabled, isLoading, isLoadingMore, limit, nextPageToken, podId]);
+    useEffect(() => {
+        setSelectedTaskId(initialTaskId);
+    }, [initialTaskId]);
+    useEffect(() => {
+        if (!enabled) {
+            setRuns([]);
+            setTotal(0);
+            setNextPageToken(null);
+            setError(null);
+            setIsLoading(false);
+            setIsLoadingMore(false);
+            return;
+        }
+        if (!autoLoad)
+            return;
+        const controller = new AbortController();
+        let cancelled = false;
+        (async () => {
+            try {
+                await refresh({}, controller.signal);
+            }
+            catch {
+                if (!cancelled) {
+                    setError(normalizeError(new Error("Failed to load agent runs."), "Failed to load agent runs."));
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+            controller.abort();
+        };
+    }, [autoLoad, enabled, refresh]);
+    const selectRun = useCallback((taskId) => {
+        setSelectedTaskId(taskId);
+    }, []);
+    const clearSelection = useCallback(() => {
+        setSelectedTaskId(null);
+    }, []);
+    return useMemo(() => {
+        const effectiveSelectedTaskId = selectedTaskId ?? runs[0]?.id ?? null;
+        const selectedRun = effectiveSelectedTaskId
+            ? runs.find((run) => run.id === effectiveSelectedTaskId) ?? null
+            : null;
+        return {
+            runs,
+            total,
+            nextPageToken,
+            selectedTaskId,
+            effectiveSelectedTaskId,
+            selectedRun,
+            isLoading,
+            isLoadingMore,
+            error,
+            selectRun,
+            clearSelection,
+            refresh,
+            loadMore,
+        };
+    }, [
+        clearSelection,
+        error,
+        isLoading,
+        isLoadingMore,
+        loadMore,
+        nextPageToken,
+        refresh,
+        runs,
+        selectRun,
+        selectedTaskId,
+        total,
+    ]);
+}

package/dist/react/useAssistantRun.d.ts

@@ -1,5 +1,6 @@
 import type { LemmaClient } from "../client.js";
 import type { SseRawEvent } from "../streams.js";
+import type { ConversationMessage } from "../types.js";
 export interface UseAssistantRunOptions {
     client: LemmaClient;
     podId?: string;
@@ -10,6 +11,14 @@ export interface UseAssistantRunOptions {
 export interface UseAssistantRunResult {
     isStreaming: boolean;
     error: Error | null;
+    status?: string;
+    messages: ConversationMessage[];
+    output: ConversationMessage["content"] | null;
+    outputText: string;
+    finalOutput: ConversationMessage["content"] | null;
+    finalOutputText: string;
+    latestAssistantMessage: ConversationMessage | null;
+    refresh: () => Promise<ConversationMessage[]>;
     sendMessage: (content: string) => Promise<void>;
     resume: () => Promise<void>;
     stop: () => Promise<void>;

package/dist/react/useAssistantRun.js

@@ -1,4 +1,5 @@
-import { useAssistantSession } from "./useAssistantSession.js";
+import { useCallback, useMemo } from "react";
+import { useConversationMessages } from "./useConversationMessages.js";
 function requireConversationId(conversationId) {
     if (!conversationId) {
         throw new Error("conversationId is required.");
@@ -6,31 +7,41 @@ function requireConversationId(conversationId) {
     return conversationId;
 }
 export function useAssistantRun({ client, podId, conversationId, onEvent, onError, }) {
-    const session = useAssistantSession({
+    const messages = useConversationMessages({
         client,
         podId,
         conversationId,
+        autoLoad: true,
+        autoResume: false,
         onEvent,
         onError,
     });
-    const sendMessage = async (content) => {
-        await session.sendMessage(content, {
-            conversationId: requireConversationId(conversationId ?? session.conversationId),
+    const sendMessage = useCallback(async (content) => {
+        await messages.sendMessage(content, {
+            conversationId: requireConversationId(conversationId ?? messages.conversationId),
             createIfMissing: false,
         });
-    };
-    const resume = async () => {
-        await session.resume(requireConversationId(conversationId ?? session.conversationId));
-    };
-    const stop = async () => {
-        await session.stop(requireConversationId(conversationId ?? session.conversationId));
-    };
-    return {
-        isStreaming: session.isStreaming,
-        error: session.error,
+    }, [conversationId, messages]);
+    const resume = useCallback(async () => {
+        await messages.resume(requireConversationId(conversationId ?? messages.conversationId));
+    }, [conversationId, messages]);
+    const stop = useCallback(async () => {
+        await messages.stop(requireConversationId(conversationId ?? messages.conversationId));
+    }, [conversationId, messages]);
+    return useMemo(() => ({
+        isStreaming: messages.isStreaming,
+        error: messages.error,
+        status: messages.status,
+        messages: messages.messages,
+        output: messages.output,
+        outputText: messages.outputText,
+        finalOutput: messages.finalOutput,
+        finalOutputText: messages.finalOutputText,
+        latestAssistantMessage: messages.latestAssistantMessage,
+        refresh: messages.refresh,
         sendMessage,
         resume,
         stop,
-        cancel: session.cancel,
-    };
+        cancel: messages.cancel,
+    }), [messages, sendMessage, resume, stop]);
 }

package/dist/react/useAssistantSession.d.ts

@@ -59,6 +59,11 @@ export interface UseAssistantSessionResult {
     conversation: Conversation | null;
     status?: string;
     messages: ConversationMessage[];
+    latestAssistantMessage: ConversationMessage | null;
+    output: ConversationMessage["content"] | null;
+    outputText: string;
+    finalOutput: ConversationMessage["content"] | null;
+    finalOutputText: string;
     streamingText: string;
     isStreaming: boolean;
     error: Error | null;

package/dist/react/useAssistantSession.js

@@ -1,15 +1,14 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { parseSSEJson, readSSE } from "../streams.js";
 import { parseAssistantStreamEvent, upsertConversationMessage } from "../assistant-events.js";
-function resolveOptionalPodId(client, podId) {
-    return podId ?? client.podId;
-}
+import { extractConversationMessageText, getLatestAssistantMessage, } from "./assistant-output.js";
+import { normalizeError } from "./utils.js";
 function applyPodScope(client, podId) {
-    const resolvedPodId = resolveOptionalPodId(client, podId);
-    if (resolvedPodId) {
-        client.setPodId(resolvedPodId);
+    const resolvedPodId = podId ?? client.podId;
+    if (resolvedPodId && resolvedPodId !== client.podId) {
+        return client.withPod(resolvedPodId);
     }
-    return resolvedPodId;
+    return client;
 }
 function requireConversationId(conversationId) {
     if (!conversationId) {
@@ -17,11 +16,6 @@ function requireConversationId(conversationId) {
     }
     return conversationId;
 }
-function normalizeError(error, fallback) {
-    if (error instanceof Error)
-        return error;
-    return new Error(fallback);
-}
 function normalizeScope(client, defaults, override) {
     const resolvedAssistantName = override?.assistantName
         ?? override?.assistantId
@@ -140,10 +134,11 @@ export function useAssistantSession(options) {
         organizationId: defaultOrganizationId ?? null,
     }), [defaultAssistantId, defaultAssistantName, defaultOrganizationId, defaultPodId]);
     const listConversations = useCallback(async (input = {}) => {
+        setError(null);
         try {
             const scope = normalizeScope(client, defaultScope, input.scope);
-            applyPodScope(client, scope.podId);
-            const response = await client.conversations.list({
+            const scopedClient = applyPodScope(client, scope.podId);
+            const response = await scopedClient.conversations.list({
                 pod_id: scope.podId ?? undefined,
                 assistant_name: scope.assistantName ?? scope.assistantId ?? undefined,
                 organization_id: scope.organizationId ?? undefined,
@@ -154,6 +149,7 @@ export function useAssistantSession(options) {
                 items: response.items ?? [],
                 limit: response.limit ?? input.limit ?? 20,
                 next_page_token: response.next_page_token,
+                total: response.total,
             };
         }
         catch (listError) {
@@ -168,30 +164,39 @@ export function useAssistantSession(options) {
         }
     }, [client, defaultScope]);
     const createConversation = useCallback(async (input = {}) => {
-        applyPodScope(client, input.podId ?? defaultPodId ?? null);
-        const payload = {
-            title: input.title ?? undefined,
-            pod_id: input.podId ?? defaultPodId ?? client.podId ?? undefined,
-            assistant_name: input.assistantName
-                ?? input.assistantId
-                ?? defaultAssistantName
-                ?? defaultAssistantId
-                ?? undefined,
-            organization_id: input.organizationId ?? defaultOrganizationId ?? undefined,
-            model: typeof input.model === "undefined"
-                ? undefined
-                : input.model,
-        };
-        const created = await client.conversations.create(payload);
-        if (input.setActive !== false) {
-            setConversationIdState(created.id);
-            setConversation(created);
-            setConversationStatus(created.status);
-            setMessages([]);
-            clearStreamingText();
-            autoResumedKeyRef.current = null;
+        setError(null);
+        try {
+            const scopedClient = applyPodScope(client, input.podId ?? defaultPodId ?? null);
+            const payload = {
+                title: input.title ?? undefined,
+                pod_id: input.podId ?? defaultPodId ?? scopedClient.podId ?? undefined,
+                assistant_name: input.assistantName
+                    ?? input.assistantId
+                    ?? defaultAssistantName
+                    ?? defaultAssistantId
+                    ?? undefined,
+                organization_id: input.organizationId ?? defaultOrganizationId ?? undefined,
+                model: typeof input.model === "undefined"
+                    ? undefined
+                    : input.model,
+            };
+            const created = await scopedClient.conversations.create(payload);
+            if (input.setActive !== false) {
+                setConversationIdState(created.id);
+                setConversation(created);
+                setConversationStatus(created.status);
+                setMessages([]);
+                clearStreamingText();
+                autoResumedKeyRef.current = null;
+            }
+            return created;
+        }
+        catch (createError) {
+            const normalized = normalizeError(createError, "Failed to create conversation.");
+            setError(normalized);
+            onErrorRef.current?.(createError);
+            throw normalized;
         }
-        return created;
     }, [
         clearStreamingText,
         client,
@@ -205,10 +210,11 @@ export function useAssistantSession(options) {
         const id = explicitConversationId ?? conversationId;
         if (!id)
             return null;
+        setError(null);
         try {
             const scope = normalizeScope(client, defaultScope);
-            applyPodScope(client, scope.podId);
-            const nextConversation = await client.conversations.get(id, {
+            const scopedClient = applyPodScope(client, scope.podId);
+            const nextConversation = await scopedClient.conversations.get(id, {
                 pod_id: scope.podId ?? undefined,
             });
             setConversation(nextConversation);
@@ -230,6 +236,7 @@ export function useAssistantSession(options) {
         if (!id) {
             return { items: [], limit: input.limit ?? 20, next_page_token: null };
         }
+        setError(null);
         try {
             const response = await client.conversations.messages.list(id, {
                 limit: input.limit,
@@ -351,48 +358,66 @@ export function useAssistantSession(options) {
         });
     }, [conversation, conversationId, createConversation, refreshConversation]);
     const sendMessage = useCallback(async (content, input = {}) => {
-        const resolvedConversation = await ensureConversation(input.conversationId, input);
-        const resolvedConversationId = requireConversationId(resolvedConversation.id);
-        cancel();
-        const controller = new AbortController();
-        abortRef.current = controller;
-        const scope = normalizeScope(client, defaultScope, input.createConversation);
-        applyPodScope(client, scope.podId);
-        const stream = await client.conversations.sendMessageStream(resolvedConversationId, { content }, {
-            pod_id: scope.podId ?? undefined,
-            signal: controller.signal,
-        });
-        setConversationStatus("RUNNING");
-        await consume({
-            stream,
-            controller,
-            streamConversationId: resolvedConversationId,
-            syncAfterStream: input.syncOnTurnEnd,
-        });
-        return resolvedConversation;
+        setError(null);
+        try {
+            const resolvedConversation = await ensureConversation(input.conversationId, input);
+            const resolvedConversationId = requireConversationId(resolvedConversation.id);
+            cancel();
+            const controller = new AbortController();
+            abortRef.current = controller;
+            const scope = normalizeScope(client, defaultScope, input.createConversation);
+            const scopedClient = applyPodScope(client, scope.podId);
+            const stream = await scopedClient.conversations.sendMessageStream(resolvedConversationId, { content }, {
+                pod_id: scope.podId ?? undefined,
+                signal: controller.signal,
+            });
+            setConversationStatus("RUNNING");
+            await consume({
+                stream,
+                controller,
+                streamConversationId: resolvedConversationId,
+                syncAfterStream: input.syncOnTurnEnd,
+            });
+            return resolvedConversation;
+        }
+        catch (sendError) {
+            const normalized = normalizeError(sendError, "Failed to send assistant message.");
+            setError(normalized);
+            onErrorRef.current?.(sendError);
+            throw normalized;
+        }
     }, [cancel, client, consume, defaultScope, ensureConversation, setConversationStatus]);
     const resume = useCallback(async (input) => {
-        const resumeInput = resolveResumeInput(input);
-        const id = requireConversationId(resumeInput.conversationId ?? conversationId);
-        if (resumeInput.onlyIfRunning && !isConversationRunningStatus(statusRef.current)) {
-            return;
+        setError(null);
+        try {
+            const resumeInput = resolveResumeInput(input);
+            const id = requireConversationId(resumeInput.conversationId ?? conversationId);
+            if (resumeInput.onlyIfRunning && !isConversationRunningStatus(statusRef.current)) {
+                return;
+            }
+            cancel();
+            const controller = new AbortController();
+            abortRef.current = controller;
+            const scope = normalizeScope(client, defaultScope);
+            const scopedClient = applyPodScope(client, scope.podId);
+            const stream = await scopedClient.conversations.resumeStream(id, {
+                pod_id: scope.podId ?? undefined,
+                signal: controller.signal,
+            });
+            setConversationStatus("RUNNING");
+            await consume({
+                stream,
+                controller,
+                streamConversationId: id,
+                syncAfterStream: resumeInput.syncOnTurnEnd,
+            });
+        }
+        catch (resumeError) {
+            const normalized = normalizeError(resumeError, "Failed to resume assistant run.");
+            setError(normalized);
+            onErrorRef.current?.(resumeError);
+            throw normalized;
         }
-        cancel();
-        const controller = new AbortController();
-        abortRef.current = controller;
-        const scope = normalizeScope(client, defaultScope);
-        applyPodScope(client, scope.podId);
-        const stream = await client.conversations.resumeStream(id, {
-            pod_id: scope.podId ?? undefined,
-            signal: controller.signal,
-        });
-        setConversationStatus("RUNNING");
-        await consume({
-            stream,
-            controller,
-            streamConversationId: id,
-            syncAfterStream: resumeInput.syncOnTurnEnd,
-        });
     }, [cancel, client, consume, conversationId, defaultScope, setConversationStatus]);
     const resumeIfRunning = useCallback(async (explicitConversationId) => {
         const id = explicitConversationId ?? conversationId;
@@ -429,14 +454,23 @@ export function useAssistantSession(options) {
         }
     }, [conversationId, isStreaming, refreshConversation, resume]);
     const stop = useCallback(async (explicitConversationId) => {
-        const id = requireConversationId(explicitConversationId ?? conversationId);
-        const scope = normalizeScope(client, defaultScope);
-        applyPodScope(client, scope.podId);
-        await client.conversations.stopRun(id, {
-            pod_id: scope.podId ?? undefined,
-        });
-        setConversationStatus("WAITING");
-        clearStreamingText();
+        setError(null);
+        try {
+            const id = requireConversationId(explicitConversationId ?? conversationId);
+            const scope = normalizeScope(client, defaultScope);
+            const scopedClient = applyPodScope(client, scope.podId);
+            await scopedClient.conversations.stopRun(id, {
+                pod_id: scope.podId ?? undefined,
+            });
+            setConversationStatus("WAITING");
+            clearStreamingText();
+        }
+        catch (stopError) {
+            const normalized = normalizeError(stopError, "Failed to stop assistant run.");
+            setError(normalized);
+            onErrorRef.current?.(stopError);
+            throw normalized;
+        }
     }, [client, conversationId, defaultScope]);
     const clearMessages = useCallback(() => {
         setMessages([]);
@@ -453,6 +487,7 @@ export function useAssistantSession(options) {
         if (!autoLoad || !conversationId) {
             return;
         }
+        const controller = new AbortController();
         let cancelled = false;
         const bootstrapConversation = async () => {
             const latestConversation = await refreshConversation(conversationId);
@@ -471,13 +506,27 @@ export function useAssistantSession(options) {
         void bootstrapConversation();
         return () => {
             cancelled = true;
+            controller.abort();
         };
     }, [autoLoad, autoResume, conversationId, loadMessages, refreshConversation, resumeIfRunning]);
+    const latestAssistantMessage = useMemo(() => getLatestAssistantMessage(messages), [messages]);
+    const output = latestAssistantMessage?.content ?? null;
+    const latestAssistantText = latestAssistantMessage
+        ? extractConversationMessageText(latestAssistantMessage.content)
+        : "";
+    const outputText = streamingText.trim() || latestAssistantText;
+    const finalOutput = !isStreaming && !isConversationRunningStatus(status) ? output : null;
+    const finalOutputText = !isStreaming && !isConversationRunningStatus(status) ? latestAssistantText : "";
     return {
         conversationId,
         conversation,
         status,
         messages,
+        latestAssistantMessage,
+        output,
+        outputText,
+        finalOutput,
+        finalOutputText,
         streamingText,
         isStreaming,
         error,

package/dist/react/useBulkRecords.d.ts

@@ -0,0 +1,20 @@
+import type { LemmaClient } from "../client.js";
+import type { DatastoreMessageResponse } from "../types.js";
+export interface UseBulkRecordsOptions {
+    client: LemmaClient;
+    podId?: string;
+    tableName: string;
+    enabled?: boolean;
+    onSuccess?: (response: DatastoreMessageResponse) => void;
+    onError?: (error: unknown) => void;
+}
+export interface UseBulkRecordsResult {
+    isSubmitting: boolean;
+    error: Error | null;
+    lastMessage: string | null;
+    createMany: (records: Record<string, unknown>[]) => Promise<DatastoreMessageResponse | null>;
+    updateMany: (records: Record<string, unknown>[]) => Promise<DatastoreMessageResponse | null>;
+    deleteMany: (recordIds: Array<string | number>) => Promise<DatastoreMessageResponse | null>;
+    reset: () => void;
+}
+export declare function useBulkRecords({ client, podId, tableName, enabled, onSuccess, onError, }: UseBulkRecordsOptions): UseBulkRecordsResult;

package/dist/react/useBulkRecords.js

@@ -0,0 +1,65 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
+export function useBulkRecords({ client, podId, tableName, enabled = true, onSuccess, onError, }) {
+    const [isSubmitting, setIsSubmitting] = useState(false);
+    const [error, setError] = useState(null);
+    const [lastMessage, setLastMessage] = useState(null);
+    const onSuccessRef = useRef(onSuccess);
+    const onErrorRef = useRef(onError);
+    useEffect(() => { onSuccessRef.current = onSuccess; }, [onSuccess]);
+    useEffect(() => { onErrorRef.current = onError; }, [onError]);
+    const trimmedTableName = tableName.trim();
+    const isEnabled = enabled && trimmedTableName.length > 0;
+    const runBulkOperation = useCallback(async (action, fallbackError) => {
+        if (!isEnabled) {
+            return null;
+        }
+        setIsSubmitting(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const response = await action(scopedClient);
+            setLastMessage(response.message ?? null);
+            onSuccessRef.current?.(response);
+            return response;
+        }
+        catch (mutationError) {
+            const normalized = normalizeError(mutationError, fallbackError);
+            setError(normalized);
+            onErrorRef.current?.(mutationError);
+            return null;
+        }
+        finally {
+            setIsSubmitting(false);
+        }
+    }, [client, isEnabled, podId]);
+    const createMany = useCallback(async (records) => {
+        if (records.length === 0)
+            return null;
+        return runBulkOperation((scopedClient) => scopedClient.records.bulk.create(trimmedTableName, records), "Failed to bulk create records.");
+    }, [runBulkOperation, trimmedTableName]);
+    const updateMany = useCallback(async (records) => {
+        if (records.length === 0)
+            return null;
+        return runBulkOperation((scopedClient) => scopedClient.records.bulk.update(trimmedTableName, records), "Failed to bulk update records.");
+    }, [runBulkOperation, trimmedTableName]);
+    const deleteMany = useCallback(async (recordIds) => {
+        if (recordIds.length === 0)
+            return null;
+        return runBulkOperation((scopedClient) => scopedClient.records.bulk.delete(trimmedTableName, recordIds), "Failed to bulk delete records.");
+    }, [runBulkOperation, trimmedTableName]);
+    const reset = useCallback(() => {
+        setError(null);
+        setIsSubmitting(false);
+        setLastMessage(null);
+    }, []);
+    return useMemo(() => ({
+        isSubmitting,
+        error,
+        lastMessage,
+        createMany,
+        updateMany,
+        deleteMany,
+        reset,
+    }), [createMany, deleteMany, error, isSubmitting, lastMessage, reset, updateMany]);
+}

package/dist/react/useConversation.d.ts

@@ -0,0 +1,18 @@
+import type { LemmaClient } from "../client.js";
+import type { Conversation } from "../types.js";
+export interface UseConversationOptions {
+    client: LemmaClient;
+    podId?: string;
+    conversationId?: string | null;
+    enabled?: boolean;
+    autoLoad?: boolean;
+}
+export interface UseConversationResult {
+    conversation: Conversation | null;
+    isLoading: boolean;
+    error: Error | null;
+    refresh: (overrides?: {
+        conversationId?: string | null;
+    }) => Promise<Conversation | null>;
+}
+export declare function useConversation({ client, podId, conversationId, enabled, autoLoad, }: UseConversationOptions): UseConversationResult;