lemma-sdk 0.2.37 → 0.2.40

package/dist/react/useTaskSession.js

@@ -1,269 +0,0 @@
-import { useCallback, useEffect, useRef, useState } from "react";
-import { parseSSEJson, readSSE } from "../streams.js";
-import { isTerminalTaskStatus, normalizeRunStatus } from "../run-utils.js";
-import { parseTaskStreamEvent, upsertTaskMessage } from "../task-events.js";
-import { normalizeError, resolvePodClient, resolvePodId } from "./utils.js";
-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);
-    const [status, setStatus] = useState(undefined);
-    const [messages, setMessages] = useState([]);
-    const [isStreaming, setIsStreaming] = useState(false);
-    const [error, setError] = useState(null);
-    const abortRef = useRef(null);
-    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) => {
-        setTaskIdState((currentTaskId) => {
-            if (currentTaskId === nextTaskId) {
-                return currentTaskId;
-            }
-            abortRef.current?.abort();
-            abortRef.current = null;
-            taskIdRef.current = nextTaskId;
-            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(() => {
-        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;
-        }
-        previousExternalTaskIdRef.current = externalTaskId;
-        setTaskId(externalTaskId);
-    }, [externalTaskId, setTaskId]);
-    const refreshTask = useCallback(async (explicitTaskId) => {
-        const id = explicitTaskId ?? taskIdRef.current;
-        if (!id)
-            return null;
-        try {
-            const scopedClient = resolvePodClient(client, resolvePodId(client, podId));
-            const nextTask = await scopedClient.tasks.get(id);
-            setTask(nextTask);
-            setTaskStatus(nextTask.status);
-            return nextTask;
-        }
-        catch (refreshError) {
-            const normalized = normalizeError(refreshError, "Failed to fetch task.");
-            setError(normalized);
-            onErrorRef.current?.(refreshError);
-            return null;
-        }
-    }, [client, podId, setTaskStatus]);
-    const loadMessages = useCallback(async (explicitTaskId) => {
-        const id = explicitTaskId ?? taskIdRef.current;
-        if (!id)
-            return [];
-        try {
-            const scopedClient = resolvePodClient(client, resolvePodId(client, podId));
-            const response = await scopedClient.tasks.messages.list(id, { limit: 100 });
-            const nextMessages = response.items ?? [];
-            setMessages(nextMessages);
-            return nextMessages;
-        }
-        catch (messageError) {
-            const normalized = normalizeError(messageError, "Failed to fetch task messages.");
-            setError(normalized);
-            onErrorRef.current?.(messageError);
-            return [];
-        }
-    }, [client, podId]);
-    const connect = useCallback(async (explicitTaskId) => {
-        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 {
-            while (!controller.signal.aborted) {
-                if (isTerminalTaskStatus(statusRef.current)) {
-                    break;
-                }
-                try {
-                    const scopedClient = resolvePodClient(client, resolvePodId(client, podId));
-                    const stream = await scopedClient.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);
-                }
-                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);
-                }
-            }
-        }
-        finally {
-            if (abortRef.current === controller) {
-                abortRef.current = null;
-            }
-            setIsStreaming(false);
-        }
-    }, [client, disconnect, podId, setTaskStatus]);
-    const start = useCallback(async (input) => {
-        setError(null);
-        const scopedClient = resolvePodClient(client, resolvePodId(client, podId));
-        const created = await scopedClient.tasks.create({
-            agent_name: input.agentName,
-            input_data: input.inputData,
-        });
-        taskIdRef.current = created.id;
-        setTask(created);
-        setTaskIdState(created.id);
-        setMessages([]);
-        setTaskStatus(created.status);
-        if (autoConnectOnStart && !autoConnect) {
-            await connect(created.id);
-        }
-        return created;
-    }, [autoConnect, autoConnectOnStart, client, connect, podId, setTaskStatus]);
-    const stop = useCallback(async () => {
-        const id = taskIdRef.current;
-        if (!id)
-            return null;
-        try {
-            const scopedClient = resolvePodClient(client, resolvePodId(client, podId));
-            const stopped = await scopedClient.tasks.stop(id);
-            setTask(stopped);
-            setTaskStatus(stopped.status);
-            return stopped;
-        }
-        catch (stopError) {
-            const normalized = normalizeError(stopError, "Failed to stop task run.");
-            setError(normalized);
-            onErrorRef.current?.(stopError);
-            return null;
-        }
-    }, [client, podId, setTaskStatus]);
-    const clearMessages = useCallback(() => {
-        setMessages([]);
-    }, []);
-    useEffect(() => {
-        if (!taskId)
-            return;
-        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,
-        status,
-        messages,
-        isStreaming,
-        error,
-        setTaskId,
-        start,
-        refreshTask,
-        loadMessages,
-        connect,
-        disconnect,
-        stop,
-        clearMessages,
-    };
-}

package/dist/task-events.d.ts

@@ -1,8 +0,0 @@
-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

@@ -1,115 +0,0 @@
-function isRecord(value) {
-    return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function normalizeStatus(status) {
-    if (typeof status !== "string")
-        return undefined;
-    const normalized = status.trim().toUpperCase();
-    return normalized.length > 0 ? normalized : undefined;
-}
-function toTaskMessage(value) {
-    if (!isRecord(value))
-        return undefined;
-    if (typeof value.id !== "string")
-        return undefined;
-    if (typeof value.role !== "string")
-        return undefined;
-    if (!("content" in value))
-        return undefined;
-    const content = value.content;
-    const message = {
-        id: value.id,
-        role: value.role,
-        content: content,
-        created_at: typeof value.created_at === "string" ? value.created_at : new Date().toISOString(),
-        metadata: isRecord(value.metadata) ? value.metadata : null,
-    };
-    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;
-    if ("payload" in record)
-        return record.payload;
-    return undefined;
-}
-function extractStatus(payload) {
-    if (isRecord(payload)) {
-        return normalizeStatus(payload.status)
-            ?? normalizeStatus(payload.task_status)
-            ?? (isRecord(payload.task) ? normalizeStatus(payload.task.status) : undefined);
-    }
-    return normalizeStatus(payload);
-}
-export function parseTaskStreamEvent(value) {
-    const directMessage = toTaskMessage(value);
-    if (directMessage) {
-        return { message: directMessage };
-    }
-    if (!isRecord(value)) {
-        return {};
-    }
-    const eventType = typeof value.type === "string" ? value.type.toLowerCase() : "";
-    const payload = extractPayload(value);
-    if (eventType === "message" || eventType === "message_added") {
-        const message = toTaskMessage(payload);
-        return message ? { message } : {};
-    }
-    if (eventType === "status"
-        || eventType === "task_status"
-        || eventType === "task"
-        || eventType === "task_updated") {
-        const task = toTask(payload) ?? (isRecord(payload) ? toTask(payload.task) : undefined);
-        const status = extractStatus(payload);
-        if (task || status) {
-            return {
-                task,
-                status: status ?? task?.status,
-            };
-        }
-    }
-    return {};
-}
-export function upsertTaskMessage(messages, incoming) {
-    const next = [...messages];
-    const index = next.findIndex((message) => message.id === incoming.id);
-    if (index >= 0) {
-        next[index] = incoming;
-    }
-    else {
-        next.push(incoming);
-    }
-    next.sort((a, b) => new Date(a.created_at).getTime() - new Date(b.created_at).getTime());
-    return next;
-}