lemma-sdk 0.2.27 → 0.2.30

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;

package/dist/react/useBulkRecords.js

@@ -0,0 +1,72 @@
+import { useCallback, useMemo, useState } from "react";
+function resolvePodClient(client, podId) {
+    if (!podId || podId === client.podId)
+        return client;
+    return client.withPod(podId);
+}
+function normalizeError(error, fallback) {
+    if (error instanceof Error)
+        return error;
+    return new Error(fallback);
+}
+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 trimmedTableName = tableName.trim();
+    const isEnabled = enabled && trimmedTableName.length > 0;
+    const runBulkOperation = useCallback(async (action, fallbackError) => {
+        if (!isEnabled) {
+            const disabledError = new Error("Bulk record operations are disabled.");
+            setError(disabledError);
+            return null;
+        }
+        setIsSubmitting(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const response = await action(scopedClient);
+            setLastMessage(response.message ?? null);
+            onSuccess?.(response);
+            return response;
+        }
+        catch (mutationError) {
+            const normalized = normalizeError(mutationError, fallbackError);
+            setError(normalized);
+            onError?.(mutationError);
+            return null;
+        }
+        finally {
+            setIsSubmitting(false);
+        }
+    }, [client, isEnabled, onError, onSuccess, 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;

package/dist/react/useConversation.js

@@ -0,0 +1,59 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+function normalizeError(error, fallback) {
+    if (error instanceof Error)
+        return error;
+    return new Error(fallback);
+}
+export function useConversation({ client, podId, conversationId = null, enabled = true, autoLoad = true, }) {
+    const [conversation, setConversation] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const trimmedConversationId = typeof conversationId === "string" ? conversationId.trim() : "";
+    const isEnabled = enabled && trimmedConversationId.length > 0;
+    const refresh = useCallback(async (overrides = {}) => {
+        const nextConversationId = typeof overrides.conversationId === "string"
+            ? overrides.conversationId.trim()
+            : trimmedConversationId;
+        if (!enabled || nextConversationId.length === 0) {
+            setConversation(null);
+            setError(null);
+            setIsLoading(false);
+            return null;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const scopedClient = podId ? client.withPod(podId) : client;
+            const nextConversation = await scopedClient.conversations.get(nextConversationId, {
+                pod_id: podId,
+            });
+            setConversation(nextConversation);
+            return nextConversation;
+        }
+        catch (refreshError) {
+            const normalized = normalizeError(refreshError, "Failed to load conversation.");
+            setError(normalized);
+            return null;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [client, enabled, podId, trimmedConversationId]);
+    useEffect(() => {
+        if (!isEnabled) {
+            setConversation(null);
+            setError(null);
+            setIsLoading(false);
+            return;
+        }
+        if (!autoLoad)
+            return;
+        void refresh();
+    }, [autoLoad, isEnabled, refresh]);
+    return useMemo(() => ({
+        conversation,
+        isLoading,
+        error,
+        refresh,
+    }), [conversation, error, isLoading, refresh]);
+}

package/dist/react/useConversationMessages.d.ts

@@ -0,0 +1,59 @@
+import type { LemmaClient } from "../client.js";
+import type { SseRawEvent } from "../streams.js";
+import type { Conversation, ConversationMessage } from "../types.js";
+import { type CreateConversationInput, type ResumeAssistantOptions, type SendAssistantMessageOptions } from "./useAssistantSession.js";
+export interface UseConversationMessagesOptions {
+    client: LemmaClient;
+    podId?: string;
+    assistantName?: string;
+    /**
+     * @deprecated Use assistantName instead.
+     */
+    assistantId?: string;
+    organizationId?: string;
+    conversationId?: string | null;
+    enabled?: boolean;
+    autoLoad?: boolean;
+    autoResume?: boolean;
+    limit?: number;
+    syncOnTurnEnd?: boolean;
+    onEvent?: (event: SseRawEvent, payload: unknown | null) => void;
+    onStatus?: (status: string) => void;
+    onMessage?: (message: ConversationMessage) => void;
+    onError?: (error: unknown) => void;
+}
+export interface UseConversationMessagesResult {
+    conversationId: string | null;
+    conversation: Conversation | null;
+    messages: ConversationMessage[];
+    status?: string;
+    isRunning: boolean;
+    isStreaming: boolean;
+    isLoading: boolean;
+    isLoadingOlder: boolean;
+    hasOlderMessages: boolean;
+    nextPageToken: string | null;
+    streamingText: string;
+    latestAssistantMessage: ConversationMessage | null;
+    output: ConversationMessage["content"] | null;
+    outputText: string;
+    finalOutput: ConversationMessage["content"] | null;
+    finalOutputText: string;
+    error: Error | null;
+    refresh: (options?: {
+        conversationId?: string | null;
+        limit?: number;
+        pageToken?: string;
+    }) => Promise<ConversationMessage[]>;
+    loadOlder: (options?: {
+        limit?: number;
+    }) => Promise<ConversationMessage[]>;
+    sendMessage: (content: string, options?: SendAssistantMessageOptions) => Promise<Conversation>;
+    resume: (conversationId?: string | null | ResumeAssistantOptions) => Promise<void>;
+    resumeIfRunning: (conversationId?: string | null) => Promise<boolean>;
+    stop: (conversationId?: string | null) => Promise<void>;
+    cancel: () => void;
+    clearMessages: () => void;
+    createConversation: (input?: CreateConversationInput) => Promise<Conversation>;
+}
+export declare function useConversationMessages({ client, podId, assistantName, assistantId, organizationId, conversationId, enabled, autoLoad, autoResume, limit, syncOnTurnEnd, onEvent, onStatus, onMessage, onError, }: UseConversationMessagesOptions): UseConversationMessagesResult;

package/dist/react/useConversationMessages.js

@@ -0,0 +1,167 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { extractConversationMessageText, getLatestAssistantMessage, isConversationRunningStatus, normalizeConversationStatus, sortConversationMessagesByCreatedAt, } from "./assistant-output.js";
+import { useAssistantSession, } from "./useAssistantSession.js";
+function resolveConversationId(preferred, fallback) {
+    return preferred ?? fallback ?? null;
+}
+function isSettledStatus(status, isStreaming) {
+    if (isStreaming)
+        return false;
+    const normalized = normalizeConversationStatus(status);
+    if (!normalized)
+        return true;
+    return !isConversationRunningStatus(normalized);
+}
+export function useConversationMessages({ client, podId, assistantName, assistantId, organizationId, conversationId = null, enabled = true, autoLoad = true, autoResume = false, limit = 100, syncOnTurnEnd = false, onEvent, onStatus, onMessage, onError, }) {
+    const [nextPageToken, setNextPageToken] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [isLoadingOlder, setIsLoadingOlder] = useState(false);
+    const { conversation: sessionConversation, conversationId: sessionConversationId, messages: sessionMessages, status, streamingText, isStreaming, error, refreshConversation, loadMessages, sendMessage, resume, resumeIfRunning, stop, cancel, clearMessages: clearSessionMessages, createConversation, } = useAssistantSession({
+        client,
+        podId,
+        assistantName,
+        assistantId,
+        organizationId,
+        conversationId: conversationId ?? undefined,
+        autoLoad: false,
+        autoResume: false,
+        syncOnTurnEnd,
+        onEvent,
+        onStatus,
+        onMessage,
+        onError,
+    });
+    const refresh = useCallback(async (options = {}) => {
+        const targetConversationId = resolveConversationId(options.conversationId, sessionConversationId);
+        if (!enabled || !targetConversationId) {
+            setNextPageToken(null);
+            setIsLoading(false);
+            return [];
+        }
+        setIsLoading(true);
+        try {
+            await refreshConversation(targetConversationId);
+            const response = await loadMessages({
+                conversationId: targetConversationId,
+                limit: options.limit ?? limit,
+                pageToken: options.pageToken,
+            });
+            setNextPageToken(response.next_page_token ?? null);
+            return sortConversationMessagesByCreatedAt(response.items ?? []);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, [enabled, limit, loadMessages, refreshConversation, sessionConversationId]);
+    const loadOlder = useCallback(async (options = {}) => {
+        const targetConversationId = sessionConversationId;
+        if (!enabled || !targetConversationId || !nextPageToken || isLoading || isLoadingOlder) {
+            return [];
+        }
+        setIsLoadingOlder(true);
+        try {
+            const response = await loadMessages({
+                conversationId: targetConversationId,
+                limit: options.limit ?? limit,
+                pageToken: nextPageToken,
+            });
+            setNextPageToken(response.next_page_token ?? null);
+            return sortConversationMessagesByCreatedAt(response.items ?? []);
+        }
+        finally {
+            setIsLoadingOlder(false);
+        }
+    }, [enabled, isLoading, isLoadingOlder, limit, loadMessages, nextPageToken, sessionConversationId]);
+    useEffect(() => {
+        if (!enabled || !conversationId) {
+            setNextPageToken(null);
+            setIsLoading(false);
+            setIsLoadingOlder(false);
+            cancel();
+            clearSessionMessages();
+            return;
+        }
+        setNextPageToken(null);
+        if (!autoLoad)
+            return;
+        let cancelled = false;
+        const bootstrap = async () => {
+            await refresh({ conversationId, limit });
+            if (cancelled || !autoResume)
+                return;
+            await resumeIfRunning(conversationId);
+        };
+        void bootstrap();
+        return () => {
+            cancelled = true;
+        };
+    }, [autoLoad, autoResume, cancel, clearSessionMessages, conversationId, enabled, limit, refresh, resumeIfRunning]);
+    const messages = useMemo(() => sortConversationMessagesByCreatedAt(sessionMessages), [sessionMessages]);
+    const latestAssistantMessage = useMemo(() => getLatestAssistantMessage(messages), [messages]);
+    const output = latestAssistantMessage?.content ?? null;
+    const latestAssistantText = latestAssistantMessage
+        ? extractConversationMessageText(latestAssistantMessage.content)
+        : "";
+    const outputText = streamingText.trim() || latestAssistantText;
+    const finalOutput = isSettledStatus(status, isStreaming) ? output : null;
+    const finalOutputText = isSettledStatus(status, isStreaming) ? latestAssistantText : "";
+    const isRunning = isConversationRunningStatus(status) || isStreaming;
+    const clearMessages = useCallback(() => {
+        clearSessionMessages();
+        setNextPageToken(null);
+    }, [clearSessionMessages]);
+    return useMemo(() => ({
+        conversationId: sessionConversationId,
+        conversation: sessionConversation,
+        messages,
+        status,
+        isRunning,
+        isStreaming,
+        isLoading,
+        isLoadingOlder,
+        hasOlderMessages: !!nextPageToken,
+        nextPageToken,
+        streamingText,
+        latestAssistantMessage,
+        output,
+        outputText,
+        finalOutput,
+        finalOutputText,
+        error,
+        refresh,
+        loadOlder,
+        sendMessage,
+        resume,
+        resumeIfRunning,
+        stop,
+        cancel,
+        clearMessages,
+        createConversation,
+    }), [
+        cancel,
+        clearMessages,
+        createConversation,
+        error,
+        finalOutput,
+        finalOutputText,
+        isLoading,
+        isLoadingOlder,
+        isRunning,
+        isStreaming,
+        latestAssistantMessage,
+        loadOlder,
+        messages,
+        nextPageToken,
+        output,
+        outputText,
+        refresh,
+        resume,
+        resumeIfRunning,
+        sendMessage,
+        sessionConversation,
+        sessionConversationId,
+        status,
+        stop,
+        streamingText,
+    ]);
+}