lemma-sdk 0.2.37 → 0.2.40

package/dist/openapi_client/services/TriggersService.js

@@ -1,109 +0,0 @@
-import { OpenAPI } from '../core/OpenAPI.js';
-import { request as __request } from '../core/request.js';
-export class TriggersService {
-    /**
-     * List Triggers
-     * List triggers.
-     * @param triggerType
-     * @param isActive
-     * @param podId
-     * @param limit
-     * @param pageToken
-     * @returns TriggerListResponse Successful Response
-     * @throws ApiError
-     */
-    static triggerList(triggerType, isActive, podId, limit = 100, pageToken) {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/triggers',
-            query: {
-                'trigger_type': triggerType,
-                'is_active': isActive,
-                'pod_id': podId,
-                'limit': limit,
-                'page_token': pageToken,
-            },
-            errors: {
-                422: `Validation Error`,
-            },
-        });
-    }
-    /**
-     * Create Trigger
-     * Create a new trigger.
-     * @param requestBody
-     * @returns TriggerResponse Successful Response
-     * @throws ApiError
-     */
-    static triggerCreate(requestBody) {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/triggers',
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                422: `Validation Error`,
-            },
-        });
-    }
-    /**
-     * Delete Trigger
-     * Delete a trigger.
-     * @param triggerId
-     * @returns void
-     * @throws ApiError
-     */
-    static triggerDelete(triggerId) {
-        return __request(OpenAPI, {
-            method: 'DELETE',
-            url: '/triggers/{trigger_id}',
-            path: {
-                'trigger_id': triggerId,
-            },
-            errors: {
-                422: `Validation Error`,
-            },
-        });
-    }
-    /**
-     * Get Trigger
-     * Get a trigger by ID.
-     * @param triggerId
-     * @returns TriggerResponse Successful Response
-     * @throws ApiError
-     */
-    static triggerGet(triggerId) {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/triggers/{trigger_id}',
-            path: {
-                'trigger_id': triggerId,
-            },
-            errors: {
-                422: `Validation Error`,
-            },
-        });
-    }
-    /**
-     * Update Trigger
-     * Update a trigger.
-     * @param triggerId
-     * @param requestBody
-     * @returns TriggerResponse Successful Response
-     * @throws ApiError
-     */
-    static triggerUpdate(triggerId, requestBody) {
-        return __request(OpenAPI, {
-            method: 'PATCH',
-            url: '/triggers/{trigger_id}',
-            path: {
-                'trigger_id': triggerId,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                422: `Validation Error`,
-            },
-        });
-    }
-}

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

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;