lemma-sdk 0.2.24 → 0.2.27

package/dist/react/useAssistantController.js

@@ -584,9 +584,10 @@ export function useAssistantController({ client, podId, assistantName, assistant
         autoLoad: false,
         onError: handleAssistantSessionError,
     });
-    const { listConversations: sessionListConversations, loadMessages: sessionLoadMessages, sendMessage: sessionSendMessage, createConversation: sessionCreateConversation, resumeIfRunning: sessionResumeIfRunning, stop: sessionStop, cancel: sessionCancel, isStreaming: sessionIsStreaming, messages: sessionMessages, streamingText: sessionStreamingText, status: sessionStatus, } = assistantSession;
+    const { conversationId: sessionConversationId, listConversations: sessionListConversations, loadMessages: sessionLoadMessages, sendMessage: sessionSendMessage, createConversation: sessionCreateConversation, resumeIfRunning: sessionResumeIfRunning, stop: sessionStop, cancel: sessionCancel, isStreaming: sessionIsStreaming, messages: sessionMessages, streamingText: sessionStreamingText, status: sessionStatus, } = assistantSession;
     const { runtimeMessages, appendOptimisticUserMessage, replaceLoadedMessages, mergeMessages, clear: clearRuntimeMessages, } = useAssistantRuntime({
         conversationId: activeConversationId,
+        sessionConversationId,
         sessionMessages,
     });
     const error = localError;

package/dist/react/useAssistantRuntime.d.ts

@@ -1,6 +1,7 @@
 import type { ConversationMessage } from "../types.js";
 export interface UseAssistantRuntimeOptions {
     conversationId?: string | null;
+    sessionConversationId?: string | null;
     sessionMessages?: ConversationMessage[];
 }
 export interface UseAssistantRuntimeResult {
@@ -12,4 +13,4 @@ export interface UseAssistantRuntimeResult {
     mergeMessages: (messages: ConversationMessage[]) => void;
     clear: () => void;
 }
-export declare function useAssistantRuntime({ conversationId, sessionMessages, }: UseAssistantRuntimeOptions): UseAssistantRuntimeResult;
+export declare function useAssistantRuntime({ conversationId, sessionConversationId, sessionMessages, }: UseAssistantRuntimeOptions): UseAssistantRuntimeResult;

package/dist/react/useAssistantRuntime.js

@@ -73,7 +73,7 @@ function buildOptimisticId() {
     }
     return `optimistic-user-${Date.now()}-${Math.random().toString(36).slice(2)}`;
 }
-export function useAssistantRuntime({ conversationId = null, sessionMessages = [], }) {
+export function useAssistantRuntime({ conversationId = null, sessionConversationId = null, sessionMessages = [], }) {
     const [runtimeMessages, setRuntimeMessages] = useState([]);
     const mergeMessages = useCallback((messages) => {
         setRuntimeMessages((previous) => {
@@ -125,13 +125,17 @@ export function useAssistantRuntime({ conversationId = null, sessionMessages = [
     useEffect(() => {
         if (sessionMessages.length === 0)
             return;
+        // Session message state can lag one render behind active conversation
+        // updates. Prefer the session's own conversation id as fallback so we
+        // never relabel stale messages into the newly selected thread.
+        const fallbackConversationId = sessionConversationId ?? conversationId;
         const normalized = sessionMessages
-            .map((message) => toRuntimeMessage(message, conversationId))
+            .map((message) => toRuntimeMessage(message, fallbackConversationId))
             .filter((message) => !conversationId || message.conversation_id === conversationId);
         if (normalized.length === 0)
             return;
         mergeMessages(normalized);
-    }, [conversationId, mergeMessages, sessionMessages]);
+    }, [conversationId, mergeMessages, sessionConversationId, sessionMessages]);
     return {
         runtimeMessages,
         appendOptimisticUserMessage,

package/dist/react/useTaskSession.js

@@ -14,6 +14,9 @@ function normalizeError(error, fallback) {
         return error;
     return new Error(fallback);
 }
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 export function useTaskSession({ client, podId, taskId: externalTaskId = null, autoConnect = true, autoConnectOnStart = true, onEvent, onStatus, onMessage, onError, }) {
     const [taskId, setTaskIdState] = useState(externalTaskId);
     const [task, setTask] = useState(null);
@@ -22,53 +25,88 @@ export function useTaskSession({ client, podId, taskId: externalTaskId = null, a
     const [isStreaming, setIsStreaming] = useState(false);
     const [error, setError] = useState(null);
     const abortRef = useRef(null);
-    const setTaskId = useCallback((nextTaskId) => {
-        setTaskIdState(nextTaskId);
-        if (!nextTaskId) {
-            setTask(null);
-            setStatus(undefined);
-            setMessages([]);
+    const previousExternalTaskIdRef = useRef(externalTaskId);
+    const taskIdRef = useRef(externalTaskId);
+    const statusRef = useRef(undefined);
+    const onEventRef = useRef(onEvent);
+    const onStatusRef = useRef(onStatus);
+    const onMessageRef = useRef(onMessage);
+    const onErrorRef = useRef(onError);
+    const setTaskStatus = useCallback((nextStatus) => {
+        const normalized = normalizeRunStatus(nextStatus);
+        setStatus(normalized);
+        statusRef.current = normalized;
+        if (normalized) {
+            onStatusRef.current?.(normalized);
         }
     }, []);
+    const setTaskId = useCallback((nextTaskId) => {
+        abortRef.current?.abort();
+        abortRef.current = null;
+        setTaskIdState((currentTaskId) => {
+            if (currentTaskId === nextTaskId) {
+                return currentTaskId;
+            }
+            setError(null);
+            setIsStreaming(false);
+            if (!nextTaskId) {
+                setTask(null);
+                setTaskStatus(undefined);
+                setMessages([]);
+            }
+            return nextTaskId;
+        });
+    }, [setTaskStatus]);
     const disconnect = useCallback(() => {
         abortRef.current?.abort();
         abortRef.current = null;
+        setIsStreaming(false);
     }, []);
     useEffect(() => {
-        if (externalTaskId === taskId)
+        taskIdRef.current = taskId;
+    }, [taskId]);
+    useEffect(() => {
+        statusRef.current = status;
+    }, [status]);
+    useEffect(() => {
+        onEventRef.current = onEvent;
+    }, [onEvent]);
+    useEffect(() => {
+        onStatusRef.current = onStatus;
+    }, [onStatus]);
+    useEffect(() => {
+        onMessageRef.current = onMessage;
+    }, [onMessage]);
+    useEffect(() => {
+        onErrorRef.current = onError;
+    }, [onError]);
+    useEffect(() => {
+        if (previousExternalTaskIdRef.current === externalTaskId) {
             return;
-        setTaskIdState(externalTaskId);
-        if (!externalTaskId) {
-            disconnect();
-            setTask(null);
-            setStatus(undefined);
-            setMessages([]);
         }
-    }, [disconnect, externalTaskId, taskId]);
+        previousExternalTaskIdRef.current = externalTaskId;
+        setTaskId(externalTaskId);
+    }, [externalTaskId, setTaskId]);
     const refreshTask = useCallback(async (explicitTaskId) => {
-        const id = explicitTaskId ?? taskId;
+        const id = explicitTaskId ?? taskIdRef.current;
         if (!id)
             return null;
         try {
             client.setPodId(resolvePodId(client, podId));
             const nextTask = await client.tasks.get(id);
             setTask(nextTask);
-            const nextStatus = normalizeRunStatus(nextTask.status);
-            setStatus(nextStatus);
-            if (nextStatus) {
-                onStatus?.(nextStatus);
-            }
+            setTaskStatus(nextTask.status);
             return nextTask;
         }
         catch (refreshError) {
             const normalized = normalizeError(refreshError, "Failed to fetch task.");
             setError(normalized);
-            onError?.(refreshError);
+            onErrorRef.current?.(refreshError);
             return null;
         }
-    }, [client, onError, onStatus, podId, taskId]);
+    }, [client, podId, setTaskStatus]);
     const loadMessages = useCallback(async (explicitTaskId) => {
-        const id = explicitTaskId ?? taskId;
+        const id = explicitTaskId ?? taskIdRef.current;
         if (!id)
             return [];
         try {
@@ -81,57 +119,86 @@ export function useTaskSession({ client, podId, taskId: externalTaskId = null, a
         catch (messageError) {
             const normalized = normalizeError(messageError, "Failed to fetch task messages.");
             setError(normalized);
-            onError?.(messageError);
+            onErrorRef.current?.(messageError);
             return [];
         }
-    }, [client, onError, podId, taskId]);
+    }, [client, podId]);
     const connect = useCallback(async (explicitTaskId) => {
-        const id = explicitTaskId ?? taskId;
+        const id = explicitTaskId ?? taskIdRef.current;
         if (!id)
             return;
         setTaskIdState(id);
+        taskIdRef.current = id;
         disconnect();
         const controller = new AbortController();
         abortRef.current = controller;
         setError(null);
         setIsStreaming(true);
+        let reconnectDelayMs = 1000;
         try {
-            client.setPodId(resolvePodId(client, podId));
-            const stream = await client.tasks.stream(id, { signal: controller.signal });
-            for await (const event of readSSE(stream)) {
-                if (controller.signal.aborted) {
+            while (!controller.signal.aborted) {
+                if (isTerminalTaskStatus(statusRef.current)) {
                     break;
                 }
-                const payload = parseSSEJson(event);
-                onEvent?.(event, payload);
-                const parsed = parseTaskStreamEvent(payload);
-                if (parsed.message) {
-                    setMessages((previous) => upsertTaskMessage(previous, parsed.message));
-                    onMessage?.(parsed.message);
+                try {
+                    client.setPodId(resolvePodId(client, podId));
+                    const stream = await client.tasks.stream(id, { signal: controller.signal });
+                    reconnectDelayMs = 1000;
+                    for await (const event of readSSE(stream)) {
+                        if (controller.signal.aborted) {
+                            break;
+                        }
+                        const payload = parseSSEJson(event);
+                        onEventRef.current?.(event, payload);
+                        const parsed = parseTaskStreamEvent(payload);
+                        if (parsed.task?.id === id) {
+                            setTask(parsed.task);
+                            setTaskStatus(parsed.task.status);
+                        }
+                        if (parsed.message) {
+                            setMessages((previous) => upsertTaskMessage(previous, parsed.message));
+                            onMessageRef.current?.(parsed.message);
+                        }
+                        if (parsed.status) {
+                            setTaskStatus(parsed.status);
+                            setTask((previous) => {
+                                if (!previous || previous.id !== id)
+                                    return previous;
+                                return {
+                                    ...previous,
+                                    status: parsed.status,
+                                };
+                            });
+                        }
+                        if (isTerminalTaskStatus(statusRef.current)) {
+                            break;
+                        }
+                    }
+                    if (controller.signal.aborted || isTerminalTaskStatus(statusRef.current)) {
+                        break;
+                    }
+                    await sleep(Math.max(reconnectDelayMs, 2000));
+                    reconnectDelayMs = Math.min(Math.max(reconnectDelayMs * 2, 2000), 6000);
                 }
-                if (parsed.status) {
-                    setStatus(parsed.status);
-                    onStatus?.(parsed.status);
-                    if (isTerminalTaskStatus(parsed.status)) {
+                catch (streamError) {
+                    if (streamError instanceof Error && streamError.name === "AbortError") {
                         break;
                     }
+                    const normalized = normalizeError(streamError, "Failed to stream task run.");
+                    setError(normalized);
+                    onErrorRef.current?.(streamError);
+                    await sleep(reconnectDelayMs);
+                    reconnectDelayMs = Math.min(reconnectDelayMs * 2, 6000);
                 }
             }
         }
-        catch (streamError) {
-            if (!(streamError instanceof Error && streamError.name === "AbortError")) {
-                const normalized = normalizeError(streamError, "Failed to stream task run.");
-                setError(normalized);
-                onError?.(streamError);
-            }
-        }
         finally {
             if (abortRef.current === controller) {
                 abortRef.current = null;
             }
             setIsStreaming(false);
         }
-    }, [client, disconnect, onError, onEvent, onMessage, onStatus, podId, taskId]);
+    }, [client, disconnect, podId, setTaskStatus]);
     const start = useCallback(async (input) => {
         setError(null);
         client.setPodId(resolvePodId(client, podId));
@@ -139,55 +206,60 @@ export function useTaskSession({ client, podId, taskId: externalTaskId = null, a
             agent_name: input.agentName,
             input_data: input.inputData,
         });
+        taskIdRef.current = created.id;
         setTask(created);
         setTaskIdState(created.id);
-        const nextStatus = normalizeRunStatus(created.status);
-        setStatus(nextStatus);
-        if (nextStatus) {
-            onStatus?.(nextStatus);
-        }
+        setMessages([]);
+        setTaskStatus(created.status);
         if (autoConnectOnStart && !autoConnect) {
             await connect(created.id);
         }
         return created;
-    }, [autoConnect, autoConnectOnStart, client, connect, onStatus, podId]);
+    }, [autoConnect, autoConnectOnStart, client, connect, podId, setTaskStatus]);
     const stop = useCallback(async () => {
-        if (!taskId)
+        const id = taskIdRef.current;
+        if (!id)
             return null;
         try {
             client.setPodId(resolvePodId(client, podId));
-            const stopped = await client.tasks.stop(taskId);
+            const stopped = await client.tasks.stop(id);
             setTask(stopped);
-            const nextStatus = normalizeRunStatus(stopped.status);
-            setStatus(nextStatus);
-            if (nextStatus) {
-                onStatus?.(nextStatus);
-            }
+            setTaskStatus(stopped.status);
             return stopped;
         }
         catch (stopError) {
             const normalized = normalizeError(stopError, "Failed to stop task run.");
             setError(normalized);
-            onError?.(stopError);
+            onErrorRef.current?.(stopError);
             return null;
         }
-    }, [client, onError, onStatus, podId, taskId]);
+    }, [client, podId, setTaskStatus]);
     const clearMessages = useCallback(() => {
         setMessages([]);
     }, []);
     useEffect(() => {
         if (!taskId)
             return;
-        void refreshTask(taskId);
-        void loadMessages(taskId);
-    }, [loadMessages, refreshTask, taskId]);
-    useEffect(() => {
-        if (!autoConnect || !taskId) {
-            return;
-        }
-        void connect(taskId);
-        return () => disconnect();
-    }, [autoConnect, connect, disconnect, taskId]);
+        let cancelled = false;
+        const bootstrapTask = async () => {
+            const latestTask = await refreshTask(taskId);
+            if (cancelled)
+                return;
+            await loadMessages(taskId);
+            if (cancelled || !autoConnect)
+                return;
+            const latestStatus = normalizeRunStatus(latestTask?.status) ?? normalizeRunStatus(statusRef.current);
+            if (isTerminalTaskStatus(latestStatus)) {
+                return;
+            }
+            await connect(taskId);
+        };
+        void bootstrapTask();
+        return () => {
+            cancelled = true;
+            disconnect();
+        };
+    }, [autoConnect, connect, disconnect, loadMessages, refreshTask, taskId]);
     return {
         taskId,
         task,

package/dist/task-events.d.ts

@@ -1,7 +1,8 @@
-import type { TaskMessage } from "./types.js";
+import type { Task, TaskMessage } from "./types.js";
 export interface ParsedTaskStreamEvent {
     message?: TaskMessage;
     status?: string;
+    task?: Task;
 }
 export declare function parseTaskStreamEvent(value: unknown): ParsedTaskStreamEvent;
 export declare function upsertTaskMessage(messages: TaskMessage[], incoming: TaskMessage): TaskMessage[];

package/dist/task-events.js

@@ -26,6 +26,37 @@ function toTaskMessage(value) {
     };
     return message;
 }
+function toTask(value) {
+    if (!isRecord(value))
+        return undefined;
+    if (typeof value.id !== "string")
+        return undefined;
+    const status = normalizeStatus(value.status);
+    if (!status)
+        return undefined;
+    if (typeof value.agent_id !== "string")
+        return undefined;
+    if (typeof value.pod_id !== "string")
+        return undefined;
+    if (typeof value.user_id !== "string")
+        return undefined;
+    if (typeof value.created_at !== "string")
+        return undefined;
+    if (typeof value.updated_at !== "string")
+        return undefined;
+    return {
+        id: value.id,
+        agent_id: value.agent_id,
+        pod_id: value.pod_id,
+        user_id: value.user_id,
+        input_data: isRecord(value.input_data) ? value.input_data : null,
+        output_data: isRecord(value.output_data) ? value.output_data : null,
+        error: typeof value.error === "string" ? value.error : null,
+        status: status,
+        created_at: value.created_at,
+        updated_at: value.updated_at,
+    };
+}
 function extractPayload(record) {
     if ("data" in record)
         return record.data;
@@ -59,8 +90,14 @@ export function parseTaskStreamEvent(value) {
         || eventType === "task_status"
         || eventType === "task"
         || eventType === "task_updated") {
+        const task = toTask(payload) ?? (isRecord(payload) ? toTask(payload.task) : undefined);
         const status = extractStatus(payload);
-        return status ? { status } : {};
+        if (task || status) {
+            return {
+                task,
+                status: status ?? task?.status,
+            };
+        }
     }
     return {};
 }

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { AgentResponse, AssistantResponse, AvailableModels, ConversationMessageResponse, ConversationResponse, CreateAgentRequest, CreateAssistantRequest, CreateTaskRequest, FlowRunEntity, FunctionRunResponse, IconUploadResponse, OrganizationInvitationResponse, OrganizationMemberResponse, OrganizationResponse, PodConfigResponse, PodMemberResponse, PodResponse, TaskMessageResponse, TaskResponse, UpdateAgentRequest, UpdateAssistantRequest, UserResponse } from "./openapi_client/index.js";
+import type { AgentResponse, AssistantResponse, AvailableModels, ConversationMessageResponse, ConversationResponse, CreateAgentRequest, CreateAssistantRequest, CreateTaskRequest, FlowRunEntity, FunctionRunResponse, IconUploadResponse, OrganizationInvitationResponse, OrganizationMemberResponse, OrganizationResponse, PodConfigResponse, PodJoinRequestCreateResponse, PodMemberResponse, PodResponse, TaskMessageResponse, TaskResponse, UpdateAgentRequest, UpdateAssistantRequest, UserResponse } from "./openapi_client/index.js";
 /** Public ergonomic types. */
 export interface PageResult<T> {
     items: T[];
@@ -54,6 +54,7 @@ export type FlowRun = FlowRunEntity;
 export type Pod = PodResponse;
 export type PodConfig = PodConfigResponse;
 export type PodMember = PodMemberResponse;
+export type PodJoinRequest = PodJoinRequestCreateResponse;
 export type Organization = OrganizationResponse;
 export type OrganizationMember = OrganizationMemberResponse;
 export type OrganizationInvitation = OrganizationInvitationResponse;

package/package.json

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

package/dist/openapi_client/models/PodStatus.d.ts

@@ -1,4 +0,0 @@
-export declare enum PodStatus {
-    ACTIVE = "ACTIVE",
-    ARCHIVED = "ARCHIVED"
-}

package/dist/openapi_client/models/PodStatus.js

@@ -1,9 +0,0 @@
-/* generated using openapi-typescript-codegen -- do not edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-export var PodStatus;
-(function (PodStatus) {
-    PodStatus["ACTIVE"] = "ACTIVE";
-    PodStatus["ARCHIVED"] = "ARCHIVED";
-})(PodStatus || (PodStatus = {}));

package/dist/openapi_client/models/PodType.d.ts

@@ -1,6 +0,0 @@
-export declare enum PodType {
-    UI = "UI",
-    ASSISTANT = "ASSISTANT",
-    HYBRID = "HYBRID",
-    AUTOMATION = "AUTOMATION"
-}

package/dist/openapi_client/models/PodType.js

@@ -1,11 +0,0 @@
-/* generated using openapi-typescript-codegen -- do not edit */
-/* istanbul ignore file */
-/* tslint:disable */
-/* eslint-disable */
-export var PodType;
-(function (PodType) {
-    PodType["UI"] = "UI";
-    PodType["ASSISTANT"] = "ASSISTANT";
-    PodType["HYBRID"] = "HYBRID";
-    PodType["AUTOMATION"] = "AUTOMATION";
-})(PodType || (PodType = {}));

package/dist/react/useAgentRun.d.ts

@@ -1,17 +0,0 @@
-import type { LemmaClient } from "../client.js";
-import { type SseRawEvent } from "../streams.js";
-export interface UseAgentRunStreamOptions {
-    client: LemmaClient;
-    podId?: string;
-    taskId?: string | null;
-    autoConnect?: boolean;
-    onEvent?: (event: SseRawEvent, payload: unknown | null) => void;
-    onError?: (error: unknown) => void;
-}
-export interface UseAgentRunStreamResult {
-    isStreaming: boolean;
-    error: Error | null;
-    connect: () => Promise<void>;
-    disconnect: () => void;
-}
-export declare function useAgentRunStream({ client, podId, taskId, autoConnect, onEvent, onError, }: UseAgentRunStreamOptions): UseAgentRunStreamResult;

package/dist/react/useAgentRun.js

@@ -1,66 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from "react";
-import { parseSSEJson, readSSE } from "../streams.js";
-function resolvePodId(client, podId) {
-    const resolved = podId ?? client.podId;
-    if (!resolved) {
-        throw new Error("podId is required. Pass podId or set it on LemmaClient.");
-    }
-    return resolved;
-}
-export function useAgentRunStream({ client, podId, taskId, autoConnect = true, onEvent, onError, }) {
-    const [isStreaming, setIsStreaming] = useState(false);
-    const [error, setError] = useState(null);
-    const abortRef = useRef(null);
-    const disconnect = useCallback(() => {
-        abortRef.current?.abort();
-        abortRef.current = null;
-    }, []);
-    const connect = useCallback(async () => {
-        if (!taskId) {
-            return;
-        }
-        disconnect();
-        const controller = new AbortController();
-        abortRef.current = controller;
-        setError(null);
-        setIsStreaming(true);
-        try {
-            client.setPodId(resolvePodId(client, podId));
-            const stream = await client.tasks.stream(taskId, { signal: controller.signal });
-            for await (const event of readSSE(stream)) {
-                if (controller.signal.aborted) {
-                    break;
-                }
-                onEvent?.(event, parseSSEJson(event));
-            }
-        }
-        catch (streamError) {
-            if (!(streamError instanceof Error && streamError.name === "AbortError")) {
-                const normalized = streamError instanceof Error
-                    ? streamError
-                    : new Error("Failed to stream agent run.");
-                setError(normalized);
-                onError?.(streamError);
-            }
-        }
-        finally {
-            if (abortRef.current === controller) {
-                abortRef.current = null;
-            }
-            setIsStreaming(false);
-        }
-    }, [client, disconnect, onError, onEvent, podId, taskId]);
-    useEffect(() => {
-        if (!autoConnect || !taskId) {
-            return;
-        }
-        void connect();
-        return () => disconnect();
-    }, [autoConnect, connect, disconnect, taskId]);
-    return {
-        isStreaming,
-        error,
-        connect,
-        disconnect,
-    };
-}