lemma-sdk 0.2.28 → 0.2.30

package/dist/react/assistant-output.js

@@ -0,0 +1,90 @@
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+export function normalizeConversationStatus(status) {
+    if (typeof status !== "string")
+        return undefined;
+    const normalized = status.trim().toUpperCase();
+    return normalized.length > 0 ? normalized : undefined;
+}
+export function isConversationRunningStatus(status) {
+    const normalized = normalizeConversationStatus(status);
+    if (!normalized)
+        return false;
+    return normalized === "RUNNING" || normalized === "IN_PROGRESS" || normalized === "PROCESSING";
+}
+function extractTextFromStructuredContentEntry(entry) {
+    if (typeof entry === "string")
+        return entry.trim();
+    if (!isRecord(entry))
+        return "";
+    if (typeof entry.text === "string")
+        return entry.text.trim();
+    if (typeof entry.content === "string")
+        return entry.content.trim();
+    if (typeof entry.value === "string")
+        return entry.value.trim();
+    if (Array.isArray(entry.content)) {
+        const nested = entry.content
+            .map((child) => extractTextFromStructuredContentEntry(child))
+            .filter((text) => text.length > 0)
+            .join("\n")
+            .trim();
+        if (nested.length > 0)
+            return nested;
+    }
+    if (Array.isArray(entry.summary)) {
+        const summary = entry.summary
+            .map((child) => extractTextFromStructuredContentEntry(child))
+            .filter((text) => text.length > 0)
+            .join("\n")
+            .trim();
+        if (summary.length > 0)
+            return summary;
+    }
+    return "";
+}
+export function extractConversationMessageText(content) {
+    if (typeof content === "string")
+        return content.trim();
+    if (Array.isArray(content)) {
+        return content
+            .map((entry) => extractTextFromStructuredContentEntry(entry))
+            .filter((text) => text.length > 0)
+            .join("\n\n")
+            .trim();
+    }
+    if (!isRecord(content))
+        return "";
+    const directContent = content.content;
+    if (typeof directContent === "string")
+        return directContent.trim();
+    if (Array.isArray(directContent)) {
+        const text = directContent
+            .map((entry) => extractTextFromStructuredContentEntry(entry))
+            .filter((entry) => entry.length > 0)
+            .join("\n\n")
+            .trim();
+        if (text.length > 0)
+            return text;
+    }
+    if (typeof content.text === "string")
+        return content.text.trim();
+    return extractTextFromStructuredContentEntry(content);
+}
+export function sortConversationMessagesByCreatedAt(messages) {
+    return [...messages].sort((a, b) => {
+        const aTime = Number.isFinite(new Date(a.created_at).getTime()) ? new Date(a.created_at).getTime() : 0;
+        const bTime = Number.isFinite(new Date(b.created_at).getTime()) ? new Date(b.created_at).getTime() : 0;
+        return aTime - bTime;
+    });
+}
+export function getLatestAssistantMessage(messages) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (typeof message?.role === "string" && message.role.toLowerCase() === "assistant") {
+            return message;
+        }
+    }
+    return null;
+}

package/dist/react/index.d.ts

@@ -4,25 +4,59 @@ export { useAuth } from "./useAuth.js";
 export type { UseAuthResult } from "./useAuth.js";
 export { useAssistantRun } from "./useAssistantRun.js";
 export type { UseAssistantRunOptions, UseAssistantRunResult } from "./useAssistantRun.js";
+export { useConversations } from "./useConversations.js";
+export type { UseConversationsOptions, UseConversationsResult } from "./useConversations.js";
+export { useConversation } from "./useConversation.js";
+export type { UseConversationOptions, UseConversationResult } from "./useConversation.js";
+export { useConversationMessages } from "./useConversationMessages.js";
+export type { UseConversationMessagesOptions, UseConversationMessagesResult, } from "./useConversationMessages.js";
+export { useAgentRun } from "./useAgentRun.js";
+export type { UseAgentRunOptions, UseAgentRunResult } from "./useAgentRun.js";
 export { useAssistantSession } from "./useAssistantSession.js";
 export type { CreateConversationInput, SendAssistantMessageOptions, UseAssistantSessionOptions, UseAssistantSessionResult, } from "./useAssistantSession.js";
 export { useAssistantRuntime } from "./useAssistantRuntime.js";
 export type { UseAssistantRuntimeOptions, UseAssistantRuntimeResult, } from "./useAssistantRuntime.js";
+export { useMembers } from "./useMembers.js";
+export type { UseMembersOptions, UseMembersResult } from "./useMembers.js";
+export { useTables } from "./useTables.js";
+export type { UseTablesOptions, UseTablesResult } from "./useTables.js";
+export { useTable } from "./useTable.js";
+export type { UseTableOptions, UseTableResult } from "./useTable.js";
+export { useRecords } from "./useRecords.js";
+export type { UseRecordsOptions, UseRecordsResult } from "./useRecords.js";
+export { useRecord } from "./useRecord.js";
+export type { UseRecordOptions, UseRecordResult } from "./useRecord.js";
+export { useCreateRecord } from "./useCreateRecord.js";
+export type { UseCreateRecordOptions, UseCreateRecordResult } from "./useCreateRecord.js";
+export { useUpdateRecord } from "./useUpdateRecord.js";
+export type { UseUpdateRecordOptions, UseUpdateRecordResult } from "./useUpdateRecord.js";
+export { useDeleteRecord } from "./useDeleteRecord.js";
+export type { UseDeleteRecordOptions, UseDeleteRecordResult } from "./useDeleteRecord.js";
+export { useBulkRecords } from "./useBulkRecords.js";
+export type { UseBulkRecordsOptions, UseBulkRecordsResult } from "./useBulkRecords.js";
+export { useJoinedRecords } from "./useJoinedRecords.js";
+export type { UseJoinedRecordsOptions, UseJoinedRecordsResult } from "./useJoinedRecords.js";
+export { useRelatedRecords } from "./useRelatedRecords.js";
+export type { RelatedRecordsColumn, RelatedRecordsInclude, RelatedRecordsResolvedInclude, UseRelatedRecordsOptions, UseRelatedRecordsResult, } from "./useRelatedRecords.js";
+export { useReverseRelatedRecords } from "./useReverseRelatedRecords.js";
+export type { ReverseRelatedRecordsColumn, ReverseRelatedRelation, ReverseRelationSelector, UseReverseRelatedRecordsOptions, UseReverseRelatedRecordsResult, } from "./useReverseRelatedRecords.js";
+export { useForeignKeyOptions } from "./useForeignKeyOptions.js";
+export type { ForeignKeyOption, UseForeignKeyOptionsOptions, UseForeignKeyOptionsResult, } from "./useForeignKeyOptions.js";
+export { useRecordSchema } from "./useRecordSchema.js";
+export type { UseRecordSchemaOptions, UseRecordSchemaResult } from "./useRecordSchema.js";
+export { useRecordForm } from "./useRecordForm.js";
+export type { UseRecordFormOptions, UseRecordFormResult } from "./useRecordForm.js";
+export { useSchemaForm } from "./useSchemaForm.js";
+export type { UseSchemaFormOptions, UseSchemaFormResult } from "./useSchemaForm.js";
 export { useAssistantController } from "./useAssistantController.js";
 export type { AssistantAction, AssistantConversationScope, AssistantMessagePart, AssistantRenderableMessage, AssistantToolInvocation, UseAssistantControllerOptions, UseAssistantControllerResult, } from "./useAssistantController.js";
-export type { AssistantConversationRenderArgs, AssistantControllerView, AssistantExperienceCustomizationProps, AssistantMessageRenderArgs, EmptyStateSuggestion, AssistantPendingFileRenderArgs, AssistantPresentedFileRenderArgs, AssistantToolRenderArgs, } from "./components/assistant-types.js";
-export { AssistantAskOverlay, AssistantComposer, AssistantConversationList, AssistantHeader, AssistantMessageViewport, AssistantModelPicker, AssistantPendingFileChip, AssistantShellLayout, AssistantStatusPill, AssistantThemeScope, } from "./components/AssistantChrome.js";
-export type { AssistantAskOverlayProps, AssistantComposerProps, AssistantConversationListProps, AssistantHeaderProps, AssistantMessageViewportProps, AssistantModelPickerProps, AssistantPendingFileChipProps, AssistantShellLayoutProps, AssistantStatusPillProps, AssistantSurfaceTone, AssistantThemeMode, AssistantThemeScopeProps, } from "./components/AssistantChrome.js";
-export { AssistantExperienceView } from "./components/AssistantExperience.js";
-export type { ActiveToolBanner, AskUserInputQuestion, AssistantChromeStyle, AssistantExperienceViewProps, AssistantRadiusScale, AssistantStatusPlacement, DisplayMessageRow, EmptyStateProps, PendingAskUserInput, PlanStepState, PlanSummaryState, } from "./components/AssistantExperience.js";
-export { AssistantEmbedded } from "./components/AssistantEmbedded.js";
-export type { AssistantEmbeddedProps } from "./components/AssistantEmbedded.js";
-export { buildDisplayMessageRows, DEFAULT_EMPTY_STATE_SUGGESTIONS, dedupToolInvocations, EmptyState, findPendingAskUserInput, formatAskUserInputAnswers, getActiveToolBanner, extractPresentFilePathsFromInvocation, latestPlanSummary, MessageGroup, PlanSummaryStrip, ThinkingIndicator, } from "./components/AssistantExperience.js";
 export { useTaskSession } from "./useTaskSession.js";
 export type { CreateTaskInput, UseTaskSessionOptions, UseTaskSessionResult, } from "./useTaskSession.js";
 export { useFunctionSession } from "./useFunctionSession.js";
 export type { UseFunctionSessionOptions, UseFunctionSessionResult, } from "./useFunctionSession.js";
 export { useFlowSession } from "./useFlowSession.js";
 export type { UseFlowSessionOptions, UseFlowSessionResult, } from "./useFlowSession.js";
+export { useWorkflowStart } from "./useWorkflowStart.js";
+export type { UseWorkflowStartOptions, UseWorkflowStartResult, } from "./useWorkflowStart.js";
 export { useFlowRunHistory } from "./useFlowRunHistory.js";
 export type { UseFlowRunHistoryOptions, UseFlowRunHistoryResult, } from "./useFlowRunHistory.js";

package/dist/react/index.js

@@ -1,14 +1,31 @@
 export { AuthGuard } from "./AuthGuard.js";
 export { useAuth } from "./useAuth.js";
 export { useAssistantRun } from "./useAssistantRun.js";
+export { useConversations } from "./useConversations.js";
+export { useConversation } from "./useConversation.js";
+export { useConversationMessages } from "./useConversationMessages.js";
+export { useAgentRun } from "./useAgentRun.js";
 export { useAssistantSession } from "./useAssistantSession.js";
 export { useAssistantRuntime } from "./useAssistantRuntime.js";
+export { useMembers } from "./useMembers.js";
+export { useTables } from "./useTables.js";
+export { useTable } from "./useTable.js";
+export { useRecords } from "./useRecords.js";
+export { useRecord } from "./useRecord.js";
+export { useCreateRecord } from "./useCreateRecord.js";
+export { useUpdateRecord } from "./useUpdateRecord.js";
+export { useDeleteRecord } from "./useDeleteRecord.js";
+export { useBulkRecords } from "./useBulkRecords.js";
+export { useJoinedRecords } from "./useJoinedRecords.js";
+export { useRelatedRecords } from "./useRelatedRecords.js";
+export { useReverseRelatedRecords } from "./useReverseRelatedRecords.js";
+export { useForeignKeyOptions } from "./useForeignKeyOptions.js";
+export { useRecordSchema } from "./useRecordSchema.js";
+export { useRecordForm } from "./useRecordForm.js";
+export { useSchemaForm } from "./useSchemaForm.js";
 export { useAssistantController } from "./useAssistantController.js";
-export { AssistantAskOverlay, AssistantComposer, AssistantConversationList, AssistantHeader, AssistantMessageViewport, AssistantModelPicker, AssistantPendingFileChip, AssistantShellLayout, AssistantStatusPill, AssistantThemeScope, } from "./components/AssistantChrome.js";
-export { AssistantExperienceView } from "./components/AssistantExperience.js";
-export { AssistantEmbedded } from "./components/AssistantEmbedded.js";
-export { buildDisplayMessageRows, DEFAULT_EMPTY_STATE_SUGGESTIONS, dedupToolInvocations, EmptyState, findPendingAskUserInput, formatAskUserInputAnswers, getActiveToolBanner, extractPresentFilePathsFromInvocation, latestPlanSummary, MessageGroup, PlanSummaryStrip, ThinkingIndicator, } from "./components/AssistantExperience.js";
 export { useTaskSession } from "./useTaskSession.js";
 export { useFunctionSession } from "./useFunctionSession.js";
 export { useFlowSession } from "./useFlowSession.js";
+export { useWorkflowStart } from "./useWorkflowStart.js";
 export { useFlowRunHistory } from "./useFlowRunHistory.js";

package/dist/react/useAgentRun.d.ts

@@ -0,0 +1,17 @@
+import type { Task } from "../types.js";
+import { type UseTaskSessionOptions, type UseTaskSessionResult } from "./useTaskSession.js";
+export interface UseAgentRunOptions extends Omit<UseTaskSessionOptions, "taskId"> {
+    agentName?: string;
+    taskId?: string | null;
+}
+export interface UseAgentRunResult extends Omit<UseTaskSessionResult, "start"> {
+    output: Task["output_data"];
+    finalOutput: Task["output_data"];
+    isWaitingForInput: boolean;
+    isFinished: boolean;
+    start: (inputData?: Record<string, unknown> | null, options?: {
+        agentName?: string;
+    }) => Promise<Task>;
+    submitInput: (content: string) => Promise<Task | null>;
+}
+export declare function useAgentRun({ client, podId, agentName, taskId, autoConnect, autoConnectOnStart, onEvent, onStatus, onMessage, onError, }: UseAgentRunOptions): UseAgentRunResult;

package/dist/react/useAgentRun.js

@@ -0,0 +1,58 @@
+import { useCallback } from "react";
+import { isTerminalTaskStatus, normalizeRunStatus } from "../run-utils.js";
+import { useTaskSession, } from "./useTaskSession.js";
+function resolveAgentName(base, override) {
+    const resolved = override ?? base;
+    if (!resolved) {
+        throw new Error("agentName is required.");
+    }
+    return resolved;
+}
+function resolvePodClient(client, podId) {
+    if (!podId || podId === client.podId)
+        return client;
+    return client.withPod(podId);
+}
+export function useAgentRun({ client, podId, agentName, taskId = null, autoConnect = true, autoConnectOnStart = true, onEvent, onStatus, onMessage, onError, }) {
+    const session = useTaskSession({
+        client,
+        podId,
+        taskId,
+        autoConnect,
+        autoConnectOnStart,
+        onEvent,
+        onStatus,
+        onMessage,
+        onError,
+    });
+    const start = useCallback(async (inputData, options) => {
+        return session.start({
+            agentName: resolveAgentName(agentName, options?.agentName),
+            inputData: inputData ?? undefined,
+        });
+    }, [agentName, session]);
+    const submitInput = useCallback(async (content) => {
+        const resolvedTaskId = session.taskId;
+        if (!resolvedTaskId) {
+            throw new Error("taskId is required to submit additional agent input.");
+        }
+        const scopedClient = resolvePodClient(client, podId);
+        await scopedClient.tasks.messages.add(resolvedTaskId, { content });
+        await session.loadMessages(resolvedTaskId);
+        return session.refreshTask(resolvedTaskId);
+    }, [client, podId, session]);
+    const normalizedStatus = normalizeRunStatus(session.status);
+    const isFinished = isTerminalTaskStatus(normalizedStatus);
+    const isWaitingForInput = normalizedStatus === "WAITING";
+    const output = session.task?.output_data ?? null;
+    const finalOutput = isFinished ? output : null;
+    return {
+        ...session,
+        output,
+        finalOutput,
+        isWaitingForInput,
+        isFinished,
+        start,
+        submitInput,
+    };
+}

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,4 @@
-import { useAssistantSession } from "./useAssistantSession.js";
+import { useConversationMessages } from "./useConversationMessages.js";
 function requireConversationId(conversationId) {
     if (!conversationId) {
         throw new Error("conversationId is required.");
@@ -6,31 +6,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),
+        await messages.sendMessage(content, {
+            conversationId: requireConversationId(conversationId ?? messages.conversationId),
             createIfMissing: false,
         });
     };
     const resume = async () => {
-        await session.resume(requireConversationId(conversationId ?? session.conversationId));
+        await messages.resume(requireConversationId(conversationId ?? messages.conversationId));
     };
     const stop = async () => {
-        await session.stop(requireConversationId(conversationId ?? session.conversationId));
+        await messages.stop(requireConversationId(conversationId ?? messages.conversationId));
     };
     return {
-        isStreaming: session.isStreaming,
-        error: session.error,
+        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,
     };
 }

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,6 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { parseSSEJson, readSSE } from "../streams.js";
 import { parseAssistantStreamEvent, upsertConversationMessage } from "../assistant-events.js";
+import { extractConversationMessageText, getLatestAssistantMessage, } from "./assistant-output.js";
 function resolveOptionalPodId(client, podId) {
     return podId ?? client.podId;
 }
@@ -140,6 +141,7 @@ 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);
@@ -168,30 +170,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 {
+            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;
+            }
+            return created;
+        }
+        catch (createError) {
+            const normalized = normalizeError(createError, "Failed to create conversation.");
+            setError(normalized);
+            onErrorRef.current?.(createError);
+            throw normalized;
         }
-        return created;
     }, [
         clearStreamingText,
         client,
@@ -205,6 +216,7 @@ export function useAssistantSession(options) {
         const id = explicitConversationId ?? conversationId;
         if (!id)
             return null;
+        setError(null);
         try {
             const scope = normalizeScope(client, defaultScope);
             applyPodScope(client, scope.podId);
@@ -230,6 +242,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 +364,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);
+            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;
+        }
+        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);
+            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,
+            });
+        }
+        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 +460,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);
+            applyPodScope(client, scope.podId);
+            await client.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([]);
@@ -473,11 +513,24 @@ export function useAssistantSession(options) {
             cancelled = true;
         };
     }, [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;