lemma-sdk 0.2.0 → 0.2.2

package/dist/namespaces/workflows.js

@@ -1,9 +1,12 @@
+import { ApiError } from "../http.js";
 import { WorkflowsService } from "../openapi_client/services/WorkflowsService.js";
 export class WorkflowsNamespace {
     client;
+    http;
     podId;
-    constructor(client, podId) {
+    constructor(client, http, podId) {
         this.client = client;
+        this.http = http;
         this.podId = podId;
     }
     list(options = {}) {
@@ -21,6 +24,9 @@ export class WorkflowsNamespace {
     delete(workflowName) {
         return this.client.request(() => WorkflowsService.workflowDelete(this.podId(), workflowName));
     }
+    visualize(workflowName) {
+        return this.client.request(() => WorkflowsService.workflowVisualize(this.podId(), workflowName));
+    }
     graph = {
         update: (workflowName, graph) => this.client.request(() => WorkflowsService.workflowGraphUpdate(this.podId(), workflowName, graph)),
     };
@@ -28,10 +34,26 @@ export class WorkflowsNamespace {
         create: (workflowName, payload = {}) => this.client.request(() => WorkflowsService.workflowInstallCreate(this.podId(), workflowName, payload)),
         delete: (workflowName, installId) => this.client.request(() => WorkflowsService.workflowInstallDelete(this.podId(), workflowName, installId)),
     };
+    async postRunAction(runId, action, podId) {
+        const encodedPodId = encodeURIComponent(podId);
+        const encodedRunId = encodeURIComponent(runId);
+        try {
+            return await this.http.request("POST", `/pods/${encodedPodId}/workflow-runs/${encodedRunId}/${action}`, { body: {} });
+        }
+        catch (error) {
+            if (error instanceof ApiError && (error.statusCode === 404 || error.statusCode === 405)) {
+                return this.http.request("POST", `/pods/${encodedPodId}/flow-runs/${encodedRunId}/${action}`, { body: {} });
+            }
+            throw error;
+        }
+    }
     runs = {
         start: (workflowName, inputs = {}) => this.client.request(() => WorkflowsService.workflowStart(this.podId(), workflowName, inputs)),
         list: (workflowName, options = {}) => this.client.request(() => WorkflowsService.workflowRunList(this.podId(), workflowName, options.limit ?? 100, options.pageToken)),
         get: (runId, podId = this.podId()) => this.client.request(() => WorkflowsService.workflowRunGet(podId, runId)),
         resume: (runId, inputs = {}, podId = this.podId()) => this.client.request(() => WorkflowsService.workflowRunResume(podId, runId, inputs)),
+        visualize: (runId, podId = this.podId()) => this.client.request(() => WorkflowsService.workflowRunVisualize(podId, runId)),
+        cancel: (runId, podId = this.podId()) => this.postRunAction(runId, "cancel", podId),
+        retry: (runId, podId = this.podId()) => this.postRunAction(runId, "retry", podId),
     };
 }

package/dist/react/index.d.ts

@@ -2,3 +2,7 @@ export { AuthGuard } from "./AuthGuard.js";
 export type { AuthGuardProps } from "./AuthGuard.js";
 export { useAuth } from "./useAuth.js";
 export type { UseAuthResult } from "./useAuth.js";
+export { useAgentRunStream } from "./useAgentRun.js";
+export type { UseAgentRunStreamOptions, UseAgentRunStreamResult } from "./useAgentRun.js";
+export { useAssistantRun } from "./useAssistantRun.js";
+export type { UseAssistantRunOptions, UseAssistantRunResult } from "./useAssistantRun.js";

package/dist/react/index.js

@@ -1,2 +1,4 @@
 export { AuthGuard } from "./AuthGuard.js";
 export { useAuth } from "./useAuth.js";
+export { useAgentRunStream } from "./useAgentRun.js";
+export { useAssistantRun } from "./useAssistantRun.js";

package/dist/react/useAgentRun.d.ts

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

@@ -0,0 +1,66 @@
+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,
+    };
+}

package/dist/react/useAssistantRun.d.ts

@@ -0,0 +1,18 @@
+import type { LemmaClient } from "../client.js";
+import { type SseRawEvent } from "../streams.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;
+    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

@@ -0,0 +1,82 @@
+import { useCallback, useRef, useState } from "react";
+import { parseSSEJson, readSSE } from "../streams.js";
+function requireConversationId(conversationId) {
+    if (!conversationId) {
+        throw new Error("conversationId is required.");
+    }
+    return conversationId;
+}
+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 useAssistantRun({ client, podId, conversationId, onEvent, onError, }) {
+    const [isStreaming, setIsStreaming] = useState(false);
+    const [error, setError] = useState(null);
+    const abortRef = useRef(null);
+    const consume = useCallback(async (stream, controller) => {
+        setIsStreaming(true);
+        setError(null);
+        try {
+            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 assistant run.");
+                setError(normalized);
+                onError?.(streamError);
+            }
+        }
+        finally {
+            if (abortRef.current === controller) {
+                abortRef.current = null;
+            }
+            setIsStreaming(false);
+        }
+    }, [onError, onEvent]);
+    const cancel = useCallback(() => {
+        abortRef.current?.abort();
+        abortRef.current = null;
+    }, []);
+    const sendMessage = useCallback(async (content) => {
+        const id = requireConversationId(conversationId);
+        cancel();
+        const controller = new AbortController();
+        abortRef.current = controller;
+        client.setPodId(resolvePodId(client, podId));
+        const stream = await client.conversations.sendMessageStream(id, { content }, { signal: controller.signal });
+        await consume(stream, controller);
+    }, [cancel, client, consume, conversationId, podId]);
+    const resume = useCallback(async () => {
+        const id = requireConversationId(conversationId);
+        cancel();
+        const controller = new AbortController();
+        abortRef.current = controller;
+        client.setPodId(resolvePodId(client, podId));
+        const stream = await client.conversations.resumeStream(id, { signal: controller.signal });
+        await consume(stream, controller);
+    }, [cancel, client, consume, conversationId, podId]);
+    const stop = useCallback(async () => {
+        const id = requireConversationId(conversationId);
+        client.setPodId(resolvePodId(client, podId));
+        await client.conversations.stopRun(id);
+    }, [client, conversationId, podId]);
+    return {
+        isStreaming,
+        error,
+        sendMessage,
+        resume,
+        stop,
+        cancel,
+    };
+}

package/dist/streams.d.ts

@@ -0,0 +1,10 @@
+export interface SseRawEvent {
+    event?: string;
+    data: string;
+    raw: string;
+}
+/**
+ * Async iterator over Server-Sent Event frames.
+ */
+export declare function readSSE(stream: ReadableStream<Uint8Array>): AsyncGenerator<SseRawEvent, void, unknown>;
+export declare function parseSSEJson<T = unknown>(event: SseRawEvent): T | null;

package/dist/streams.js

@@ -0,0 +1,68 @@
+/**
+ * Async iterator over Server-Sent Event frames.
+ */
+export async function* readSSE(stream) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let eventName;
+    let dataLines = [];
+    const flush = () => {
+        if (dataLines.length === 0) {
+            eventName = undefined;
+            return null;
+        }
+        const data = dataLines.join("\n");
+        const raw = `${eventName ? `event: ${eventName}\n` : ""}${dataLines
+            .map((line) => `data: ${line}`)
+            .join("\n")}`;
+        const next = {
+            event: eventName,
+            data,
+            raw,
+        };
+        eventName = undefined;
+        dataLines = [];
+        return next;
+    };
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+            const trimmed = line.endsWith("\r") ? line.slice(0, -1) : line;
+            if (trimmed === "") {
+                const event = flush();
+                if (event) {
+                    yield event;
+                }
+                continue;
+            }
+            if (trimmed.startsWith("event:")) {
+                eventName = trimmed.slice("event:".length).trim();
+                continue;
+            }
+            if (trimmed.startsWith("data:")) {
+                dataLines.push(trimmed.slice("data:".length).trim());
+            }
+        }
+    }
+    const event = flush();
+    if (event) {
+        yield event;
+    }
+}
+export function parseSSEJson(event) {
+    if (!event.data || event.data === "[DONE]") {
+        return null;
+    }
+    try {
+        return JSON.parse(event.data);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/types.d.ts

@@ -1,5 +1,6 @@
 import type { RecordFilter as GeneratedRecordFilter } from "./openapi_client/models/RecordFilter.js";
 import type { RecordSort as GeneratedRecordSort } from "./openapi_client/models/RecordSort.js";
+import type { AgentResponse, AssistantResponse, AvailableModels, ConversationMessageResponse, ConversationResponse, CreateAgentRequest, CreateAssistantRequest, IconUploadResponse, OrganizationInvitationResponse, OrganizationMemberResponse, OrganizationResponse, PodConfigResponse, PodMemberResponse, PodResponse, TaskMessageResponse, TaskResponse, UpdateAgentRequest, UpdateAssistantRequest, UserResponse } from "./openapi_client/index.js";
 /** Public ergonomic types. */
 export interface PageResult<T> {
     items: T[];
@@ -13,15 +14,52 @@ export interface ListRecordsOptions {
     sort?: RecordSort[];
     limit?: number;
     pageToken?: string;
+    offset?: number;
+    sortBy?: string;
+    order?: "asc" | "desc" | string;
+    params?: Record<string, string | number | boolean | undefined | null>;
 }
 export interface RunFunctionOptions {
     /** Input payload for the function */
     input?: Record<string, unknown>;
 }
 export interface CreateTaskOptions {
-    agentName: string;
+    /** Preferred field in newer APIs */
+    agentId?: string;
+    /** Backward-compatible alias supported by older APIs */
+    agentName?: string;
     input?: Record<string, unknown>;
+    runtimeAccountIds?: string[];
 }
 export interface WorkflowRunInputs {
     [key: string]: unknown;
 }
+export interface StreamOptions {
+    signal?: AbortSignal;
+}
+/** Ergonomic entity aliases (instead of *Response/*Request names). */
+export type Agent = AgentResponse;
+export type CreateAgentInput = CreateAgentRequest;
+export type UpdateAgentInput = UpdateAgentRequest;
+export type Assistant = AssistantResponse;
+export type CreateAssistantInput = CreateAssistantRequest;
+export type UpdateAssistantInput = UpdateAssistantRequest;
+export type Conversation = ConversationResponse;
+export type ConversationMessage = ConversationMessageResponse;
+export type ConversationModel = `${AvailableModels}`;
+export type Task = TaskResponse;
+export type TaskMessage = TaskMessageResponse;
+export type Pod = PodResponse;
+export type PodConfig = PodConfigResponse;
+export type PodMember = PodMemberResponse;
+export type Organization = OrganizationResponse;
+export type OrganizationMember = OrganizationMemberResponse;
+export type OrganizationInvitation = OrganizationInvitationResponse;
+export type User = UserResponse;
+export type UploadedIcon = IconUploadResponse;
+/** Generic cursor-style page shape used by many list endpoints. */
+export interface CursorPage<T> {
+    items: T[];
+    limit: number;
+    next_page_token?: string | null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lemma-sdk",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Official TypeScript SDK for Lemma pod-scoped APIs",
   "type": "module",
   "main": "dist/index.js",
@@ -41,15 +41,15 @@
     "build:bundle": "tsc -p tsconfig.bundle.json && node ./scripts/build_browser_bundle.mjs",
     "clean": "rm -rf dist",
     "prepublishOnly": "npm run build",
-    "release:check": "npm run build && npm_config_cache=.npm-cache npm pack --dry-run",
-    "docs:dev": "cd docs && npx mintlify dev",
-    "docs:validate": "cd docs && npx mintlify validate"
+    "release:check": "npm run build && npm_config_cache=.npm-cache npm pack --dry-run"
   },
   "peerDependencies": {
     "react": ">=17"
   },
   "peerDependenciesMeta": {
-    "react": { "optional": true }
+    "react": {
+      "optional": true
+    }
   },
   "dependencies": {
     "supertokens-web-js": "^0.16.0"