lemma-sdk 0.2.36 → 0.2.38

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]);
-}

package/dist/react/useTaskSession.d.ts

@@ -1,35 +0,0 @@
-import type { LemmaClient } from "../client.js";
-import { type SseRawEvent } from "../streams.js";
-import type { Task, TaskMessage } from "../types.js";
-export interface CreateTaskInput {
-    agentName: string;
-    inputData?: Record<string, unknown> | null;
-}
-export interface UseTaskSessionOptions {
-    client: LemmaClient;
-    podId?: string;
-    taskId?: string | null;
-    autoConnect?: boolean;
-    autoConnectOnStart?: boolean;
-    onEvent?: (event: SseRawEvent, payload: unknown | null) => void;
-    onStatus?: (status: string) => void;
-    onMessage?: (message: TaskMessage) => void;
-    onError?: (error: unknown) => void;
-}
-export interface UseTaskSessionResult {
-    taskId: string | null;
-    task: Task | null;
-    status?: string;
-    messages: TaskMessage[];
-    isStreaming: boolean;
-    error: Error | null;
-    setTaskId: (taskId: string | null) => void;
-    start: (input: CreateTaskInput) => Promise<Task>;
-    refreshTask: (taskId?: string | null) => Promise<Task | null>;
-    loadMessages: (taskId?: string | null) => Promise<TaskMessage[]>;
-    connect: (taskId?: string | null) => Promise<void>;
-    disconnect: () => void;
-    stop: () => Promise<Task | null>;
-    clearMessages: () => void;
-}
-export declare function useTaskSession({ client, podId, taskId: externalTaskId, autoConnect, autoConnectOnStart, onEvent, onStatus, onMessage, onError, }: UseTaskSessionOptions): UseTaskSessionResult;

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;
-}