lemma-sdk 0.2.37 → 0.2.38

package/dist/run-utils.d.ts

@@ -1,15 +1,11 @@
 import type { FlowRunStatus, FunctionRunStatus } from "./openapi_client/index.js";
-import type { TaskStatus } from "./types.js";
-export type AnyRunStatus = TaskStatus | FunctionRunStatus | FlowRunStatus | (string & {});
+export type AnyRunStatus = FunctionRunStatus | FlowRunStatus | (string & {});
 interface BackoffOptions {
     baseMs?: number;
     maxMs?: number;
     factor?: number;
 }
 export declare function normalizeRunStatus(status: unknown): string | undefined;
-export declare function isTerminalTaskStatus(status: unknown, options?: {
-    treatWaitingAsTerminal?: boolean;
-}): boolean;
 export declare function isTerminalFunctionStatus(status: unknown): boolean;
 export declare function isTerminalFlowStatus(status: unknown, options?: {
     treatWaitingAsTerminal?: boolean;

package/dist/run-utils.js

@@ -1,4 +1,3 @@
-const TASK_TERMINAL = new Set(["COMPLETED", "FAILED", "CANCELLED", "STOPPED"]);
 const FUNCTION_TERMINAL = new Set(["COMPLETED", "FAILED", "CANCELLED"]);
 const FLOW_TERMINAL = new Set(["COMPLETED", "FAILED", "CANCELLED"]);
 export function normalizeRunStatus(status) {
@@ -8,15 +7,6 @@ export function normalizeRunStatus(status) {
     const normalized = status.trim().toUpperCase();
     return normalized.length > 0 ? normalized : undefined;
 }
-export function isTerminalTaskStatus(status, options = {}) {
-    const normalized = normalizeRunStatus(status);
-    if (!normalized)
-        return false;
-    if (normalized === "WAITING") {
-        return options.treatWaitingAsTerminal === true;
-    }
-    return TASK_TERMINAL.has(normalized);
-}
 export function isTerminalFunctionStatus(status) {
     const normalized = normalizeRunStatus(status);
     return !!normalized && FUNCTION_TERMINAL.has(normalized);

package/dist/types.d.ts

@@ -35,8 +35,6 @@ export interface RunFunctionOptions {
     /** Input payload for the function */
     input?: Record<string, unknown>;
 }
-/** Alias kept for backward compatibility; shape follows generated OpenAPI schema exactly. */
-export type CreateTaskOptions = CreateTaskRequest;
 export interface WorkflowRunInputs {
     [key: string]: unknown;
 }
@@ -59,51 +57,11 @@ export interface ConversationMessageResponse {
     created_at: string;
     conversation_id?: string;
     sequence?: number;
-    agent_run_id?: string | null;
     metadata?: Record<string, unknown> | null;
     tool_call_id?: string | null;
     tool_name?: string | null;
 }
 export type ConversationMessage = ConversationMessageResponse;
-export type TaskStatus = "PENDING" | "RUNNING" | "WAITING" | "COMPLETED" | "FAILED" | "CANCELLED" | "STOPPED" | (string & {});
-export interface CreateTaskRequest {
-    agent_name: string;
-    input_data?: Record<string, unknown> | null;
-    title?: string | null;
-    conversation_id?: string | null;
-    content?: string | null;
-}
-export interface AddMessageRequest {
-    content: string;
-}
-export interface TaskResponse {
-    id: string;
-    agent_id?: string | null;
-    agent_name?: string | null;
-    pod_id: string;
-    user_id?: string;
-    input_data?: Record<string, unknown> | null;
-    output_data?: unknown;
-    error?: string | null;
-    status?: TaskStatus;
-    created_at?: string;
-    updated_at?: string;
-    conversation?: Conversation;
-}
-export interface TaskListResponse {
-    items: TaskResponse[];
-    limit: number;
-    next_page_token?: string | null;
-    total?: number;
-}
-export type TaskMessageResponse = ConversationMessageResponse;
-export interface TaskMessageListResponse {
-    items: TaskMessageResponse[];
-    limit: number;
-    next_page_token?: string | null;
-}
-export type Task = TaskResponse;
-export type TaskMessage = TaskMessageResponse;
 export type FunctionRun = FunctionRunResponse;
 export type FlowRun = FlowRunEntity;
 export type Workflow = FlowResponse;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lemma-sdk",
-  "version": "0.2.37",
+  "version": "0.2.38",
   "description": "Official TypeScript SDK for Lemma pod-scoped APIs",
   "type": "module",
   "main": "dist/index.js",

package/dist/namespaces/tasks.d.ts

@@ -1,25 +0,0 @@
-import type { HttpClient } from "../http.js";
-import type { AddMessageRequest, CreateTaskRequest, TaskListResponse, TaskMessageListResponse, TaskResponse } from "../types.js";
-export declare class TasksNamespace {
-    private readonly http;
-    private readonly podId;
-    constructor(http: HttpClient, podId: () => string);
-    list(options?: {
-        agent_name?: string;
-        limit?: number;
-        page_token?: string;
-    }): Promise<TaskListResponse>;
-    create(payload: CreateTaskRequest): Promise<TaskResponse>;
-    get(taskId: string): Promise<TaskResponse>;
-    stop(taskId: string): Promise<TaskResponse>;
-    stream(taskId: string, options?: {
-        signal?: AbortSignal;
-    }): Promise<ReadableStream<Uint8Array<ArrayBufferLike>>>;
-    readonly messages: {
-        list: (taskId: string, options?: {
-            limit?: number;
-            page_token?: string;
-        }) => Promise<TaskMessageListResponse>;
-        add: (taskId: string, payload: AddMessageRequest) => Promise<TaskResponse>;
-    };
-}

package/dist/namespaces/tasks.js

@@ -1,91 +0,0 @@
-function toTask(conversation, inputData) {
-    return {
-        id: conversation.id,
-        agent_id: conversation.agent_id,
-        pod_id: conversation.pod_id,
-        user_id: conversation.user_id,
-        input_data: inputData ?? null,
-        output_data: null,
-        error: null,
-        status: conversation.status?.toUpperCase() ?? "WAITING",
-        created_at: conversation.created_at,
-        updated_at: conversation.updated_at,
-        conversation,
-    };
-}
-function normalizeConversation(conversation) {
-    return {
-        ...conversation,
-        model: conversation.model ?? conversation.model_name ?? null,
-        status: conversation.status ?? "waiting",
-    };
-}
-function normalizeMessages(messages) {
-    return messages;
-}
-export class TasksNamespace {
-    http;
-    podId;
-    constructor(http, podId) {
-        this.http = http;
-        this.podId = podId;
-    }
-    list(options = {}) {
-        return this.http.request("GET", `/pods/${this.podId()}/conversations`, {
-            params: {
-                agent_name: options.agent_name,
-                limit: options.limit ?? 100,
-                page_token: options.page_token,
-            },
-        }).then((response) => {
-            const conversations = (response.items ?? []).map(normalizeConversation);
-            return {
-                items: conversations.map((conversation) => toTask(conversation)),
-                limit: response.limit ?? options.limit ?? 100,
-                next_page_token: response.next_page_token ?? null,
-                total: response.total,
-            };
-        });
-    }
-    create(payload) {
-        return this.http.request("POST", `/pods/${this.podId()}/conversations`, {
-            body: {
-                agent_name: payload.agent_name,
-                title: payload.title ?? payload.content ?? payload.agent_name,
-            },
-        }).then((conversation) => toTask(normalizeConversation(conversation), payload.input_data));
-    }
-    get(taskId) {
-        return this.http.request("GET", `/pods/${this.podId()}/conversations/${taskId}`)
-            .then((conversation) => toTask(normalizeConversation(conversation)));
-    }
-    stop(taskId) {
-        return this.http.request("POST", `/pods/${this.podId()}/conversations/${taskId}/stop`, {
-            body: {},
-        }).then((conversation) => toTask(normalizeConversation(conversation)));
-    }
-    stream(taskId, options = {}) {
-        return this.http.stream(`/pods/${this.podId()}/conversations/${taskId}/stream`, {
-            signal: options.signal,
-            headers: {
-                Accept: "text/event-stream",
-            },
-        });
-    }
-    messages = {
-        list: (taskId, options = {}) => this.http.request("GET", `/pods/${this.podId()}/conversations/${taskId}/messages`, {
-            params: {
-                limit: options.limit ?? 100,
-                after_sequence: options.page_token,
-            },
-        }).then((response) => ({
-            ...response,
-            items: normalizeMessages(response.items ?? []),
-        })),
-        add: (taskId, payload) => {
-            return this.http.request("POST", `/pods/${this.podId()}/conversations/${taskId}/messages`, {
-                body: payload,
-            }).then(() => this.get(taskId));
-        },
-    };
-}

package/dist/react/useAgentRun.d.ts

@@ -1,38 +0,0 @@
-import type { Conversation, ConversationMessage, Task } from "../types.js";
-import { type UseAssistantSessionOptions } from "./useAssistantSession.js";
-export interface UseAgentRunOptions extends Omit<UseAssistantSessionOptions, "agentName" | "assistantName" | "assistantId" | "conversationId"> {
-    agentName?: string;
-    conversationId?: string | null;
-    taskId?: string | null;
-    autoConnect?: boolean;
-    autoConnectOnStart?: boolean;
-}
-export interface UseAgentRunResult {
-    taskId: string | null;
-    conversationId: string | null;
-    task: Task | null;
-    conversation: Conversation | null;
-    status?: string;
-    messages: ConversationMessage[];
-    output: unknown;
-    finalOutput: unknown;
-    outputText: string;
-    finalOutputText: string;
-    isStreaming: boolean;
-    error: Error | null;
-    isWaitingForInput: boolean;
-    isFinished: boolean;
-    setTaskId: (taskId: string | null) => void;
-    setConversationId: (conversationId: string | null) => void;
-    start: (inputData?: Record<string, unknown> | null, options?: {
-        agentName?: string;
-    }) => Promise<Task>;
-    submitInput: (content: string) => Promise<Task | null>;
-    refreshTask: (taskId?: string | null) => Promise<Task | null>;
-    loadMessages: (taskId?: string | null) => Promise<ConversationMessage[]>;
-    connect: (taskId?: string | null) => Promise<void>;
-    disconnect: () => void;
-    stop: () => Promise<Task | null>;
-    clearMessages: () => void;
-}
-export declare function useAgentRun({ client, podId, agentName, conversationId, taskId, autoConnect, autoConnectOnStart, autoLoad, autoResume, syncOnTurnEnd, onEvent, onStatus, onMessage, onError, }: UseAgentRunOptions): UseAgentRunResult;

package/dist/react/useAgentRun.js

@@ -1,149 +0,0 @@
-import { useCallback, useMemo } from "react";
-import { extractConversationMessageText, getLatestAssistantMessage, isConversationRunningStatus, normalizeConversationStatus, } from "./assistant-output.js";
-import { useAssistantSession, } from "./useAssistantSession.js";
-function resolveAgentName(base, override) {
-    const resolved = override ?? base;
-    if (!resolved) {
-        throw new Error("agentName is required.");
-    }
-    return resolved;
-}
-function stringifyAgentInput(inputData) {
-    if (!inputData || Object.keys(inputData).length === 0) {
-        return "";
-    }
-    const prompt = inputData.prompt ?? inputData.message ?? inputData.content;
-    if (typeof prompt === "string" && prompt.trim().length > 0 && Object.keys(inputData).length === 1) {
-        return prompt.trim();
-    }
-    return JSON.stringify(inputData, null, 2);
-}
-function taskFromConversation(conversation, status, inputData, output) {
-    if (!conversation)
-        return null;
-    return {
-        id: conversation.id,
-        agent_id: conversation.agent_id,
-        pod_id: conversation.pod_id,
-        user_id: conversation.user_id,
-        input_data: inputData ?? null,
-        output_data: output ?? null,
-        error: null,
-        status: normalizeConversationStatus(status ?? conversation.status) ?? "WAITING",
-        created_at: conversation.created_at,
-        updated_at: conversation.updated_at,
-        conversation,
-    };
-}
-export function useAgentRun({ client, podId, agentName, conversationId, taskId = null, autoConnect = true, autoConnectOnStart = true, autoLoad, autoResume, syncOnTurnEnd, onEvent, onStatus, onMessage, onError, }) {
-    const session = useAssistantSession({
-        client,
-        podId,
-        agentName,
-        conversationId: conversationId ?? taskId,
-        autoLoad: autoLoad ?? autoConnect,
-        autoResume: autoResume ?? autoConnect,
-        syncOnTurnEnd,
-        onEvent,
-        onStatus,
-        onMessage,
-        onError,
-    });
-    const start = useCallback(async (inputData, options) => {
-        const resolvedAgentName = resolveAgentName(agentName, options?.agentName);
-        const content = stringifyAgentInput(inputData);
-        const conversation = await session.createConversation({
-            agentName: resolvedAgentName,
-            title: content ? content.slice(0, 120) : resolvedAgentName,
-            setActive: true,
-        });
-        if (content) {
-            await session.sendMessage(content, {
-                conversationId: conversation.id,
-                createIfMissing: false,
-                syncOnTurnEnd,
-            });
-        }
-        else if (autoConnectOnStart) {
-            await session.resume(conversation.id);
-        }
-        return taskFromConversation(conversation, session.status, inputData) ?? {
-            id: conversation.id,
-            agent_id: conversation.agent_id,
-            pod_id: conversation.pod_id,
-            user_id: conversation.user_id,
-            input_data: inputData ?? null,
-            output_data: null,
-            error: null,
-            status: "WAITING",
-            created_at: conversation.created_at,
-            updated_at: conversation.updated_at,
-            conversation,
-        };
-    }, [agentName, autoConnectOnStart, session, syncOnTurnEnd]);
-    const submitInput = useCallback(async (content) => {
-        const resolvedConversationId = session.conversationId;
-        if (!resolvedConversationId) {
-            throw new Error("conversationId is required to submit additional agent input.");
-        }
-        await session.sendMessage(content, {
-            conversationId: resolvedConversationId,
-            createIfMissing: false,
-            syncOnTurnEnd,
-        });
-        return taskFromConversation(session.conversation, session.status);
-    }, [session, syncOnTurnEnd]);
-    const refreshTask = useCallback(async (explicitTaskId) => {
-        const conversation = await session.refreshConversation(explicitTaskId);
-        return taskFromConversation(conversation, session.status);
-    }, [session]);
-    const loadMessages = useCallback(async (explicitTaskId) => {
-        const response = await session.loadMessages({ conversationId: explicitTaskId });
-        return response.items;
-    }, [session]);
-    const connect = useCallback(async (explicitTaskId) => {
-        await session.resume(explicitTaskId);
-    }, [session]);
-    const stop = useCallback(async () => {
-        await session.stop();
-        return taskFromConversation(session.conversation, "WAITING");
-    }, [session]);
-    return useMemo(() => {
-        const latestAssistantMessage = getLatestAssistantMessage(session.messages);
-        const output = latestAssistantMessage?.content ?? session.output ?? null;
-        const outputText = latestAssistantMessage
-            ? extractConversationMessageText(latestAssistantMessage.content)
-            : session.outputText;
-        const normalizedStatus = normalizeConversationStatus(session.status);
-        const running = isConversationRunningStatus(normalizedStatus) || session.isStreaming;
-        const isWaitingForInput = normalizedStatus === "WAITING";
-        const isFinished = !!latestAssistantMessage && !running;
-        const task = taskFromConversation(session.conversation, session.status, null, output);
-        return {
-            taskId: session.conversationId,
-            conversationId: session.conversationId,
-            task,
-            conversation: session.conversation,
-            status: normalizedStatus,
-            messages: session.messages,
-            output,
-            finalOutput: isFinished ? output : null,
-            outputText,
-            finalOutputText: isFinished ? outputText : "",
-            isStreaming: session.isStreaming,
-            error: session.error,
-            isWaitingForInput,
-            isFinished,
-            setTaskId: session.setConversationId,
-            setConversationId: session.setConversationId,
-            start,
-            submitInput,
-            refreshTask,
-            loadMessages,
-            connect,
-            disconnect: session.cancel,
-            stop,
-            clearMessages: session.clearMessages,
-        };
-    }, [connect, loadMessages, refreshTask, session, start, stop, submitInput]);
-}

package/dist/react/useAgentRuns.d.ts

@@ -1,33 +0,0 @@
-import type { LemmaClient } from "../client.js";
-import type { Task } from "../types.js";
-export interface UseAgentRunsOptions {
-    client: LemmaClient;
-    podId?: string;
-    agentName?: string;
-    enabled?: boolean;
-    autoLoad?: boolean;
-    limit?: number;
-    pageToken?: string;
-    initialTaskId?: string | null;
-}
-export interface UseAgentRunsResult {
-    runs: Task[];
-    total: number;
-    nextPageToken: string | null;
-    selectedTaskId: string | null;
-    effectiveSelectedTaskId: string | null;
-    selectedRun: Task | null;
-    isLoading: boolean;
-    isLoadingMore: boolean;
-    error: Error | null;
-    selectRun: (taskId: string | null) => void;
-    clearSelection: () => void;
-    refresh: (overrides?: {
-        limit?: number;
-        pageToken?: string;
-    }) => Promise<Task[]>;
-    loadMore: (overrides?: {
-        limit?: number;
-    }) => Promise<Task[]>;
-}
-export declare function useAgentRuns({ client, podId, agentName, enabled, autoLoad, limit, pageToken, initialTaskId, }: UseAgentRunsOptions): UseAgentRunsResult;

package/dist/react/useAgentRuns.js

@@ -1,149 +0,0 @@
-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,27 +0,0 @@
-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;
-    conversationId?: string | null;
-    onEvent?: (event: SseRawEvent, payload: unknown | null) => void;
-    onError?: (error: unknown) => void;
-}
-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>;
-    cancel: () => void;
-}
-export declare function useAssistantRun({ client, podId, conversationId, onEvent, onError, }: UseAssistantRunOptions): UseAssistantRunResult;

package/dist/react/useAssistantRun.js

@@ -1,47 +0,0 @@
-import { useCallback, useMemo } from "react";
-import { useConversationMessages } from "./useConversationMessages.js";
-function requireConversationId(conversationId) {
-    if (!conversationId) {
-        throw new Error("conversationId is required.");
-    }
-    return conversationId;
-}
-export function useAssistantRun({ client, podId, conversationId, onEvent, onError, }) {
-    const messages = useConversationMessages({
-        client,
-        podId,
-        conversationId,
-        autoLoad: true,
-        autoResume: false,
-        onEvent,
-        onError,
-    });
-    const sendMessage = useCallback(async (content) => {
-        await messages.sendMessage(content, {
-            conversationId: requireConversationId(conversationId ?? messages.conversationId),
-            createIfMissing: false,
-        });
-    }, [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: messages.cancel,
-    }), [messages, sendMessage, resume, stop]);
-}