lemma-sdk 0.2.32 → 0.2.33

package/dist/react/useFileSearch.js

@@ -0,0 +1,64 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
+export function useFileSearch({ client, podId, query = "", enabled = true, autoLoad = true, minQueryLength = 1, limit = 10, searchMethod, }) {
+    const [response, setResponse] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const trimmedQuery = query.trim();
+    const reset = useCallback(() => {
+        setResponse(null);
+        setError(null);
+        setIsLoading(false);
+    }, []);
+    const search = useCallback(async (overrides = {}, signal) => {
+        const nextQuery = (overrides.query ?? trimmedQuery).trim();
+        if (!enabled || nextQuery.length < minQueryLength) {
+            reset();
+            return null;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const nextResponse = await scopedClient.files.search(nextQuery, {
+                limit: overrides.limit ?? limit,
+                searchMethod: overrides.searchMethod ?? searchMethod,
+            });
+            if (signal?.aborted)
+                return null;
+            setResponse(nextResponse);
+            return nextResponse;
+        }
+        catch (searchError) {
+            if (signal?.aborted)
+                return null;
+            setError(normalizeError(searchError, "Failed to search files."));
+            setResponse(null);
+            return null;
+        }
+        finally {
+            if (!signal?.aborted)
+                setIsLoading(false);
+        }
+    }, [client, enabled, limit, minQueryLength, podId, reset, searchMethod, trimmedQuery]);
+    useEffect(() => {
+        if (!enabled || !autoLoad)
+            return;
+        if (trimmedQuery.length < minQueryLength) {
+            reset();
+            return;
+        }
+        const controller = new AbortController();
+        void search({}, controller.signal);
+        return () => controller.abort();
+    }, [autoLoad, enabled, minQueryLength, reset, search, trimmedQuery]);
+    return useMemo(() => ({
+        response,
+        results: response?.results ?? [],
+        totalResults: response?.total_results ?? 0,
+        isLoading,
+        error,
+        search,
+        reset,
+    }), [error, isLoading, reset, response, search]);
+}

package/dist/react/useFileTree.d.ts

@@ -0,0 +1,21 @@
+import type { LemmaClient } from "../client.js";
+import type { DirectoryTreeNode, DirectoryTreeResponse } from "../types.js";
+export interface UseFileTreeOptions {
+    client: LemmaClient;
+    podId?: string;
+    enabled?: boolean;
+    autoLoad?: boolean;
+    rootPath?: string;
+    filesPerDirectory?: number;
+}
+export interface UseFileTreeResult {
+    tree: DirectoryTreeNode | null;
+    response: DirectoryTreeResponse | null;
+    isLoading: boolean;
+    error: Error | null;
+    refresh: (overrides?: {
+        rootPath?: string;
+        filesPerDirectory?: number;
+    }) => Promise<DirectoryTreeResponse | null>;
+}
+export declare function useFileTree({ client, podId, enabled, autoLoad, rootPath, filesPerDirectory, }: UseFileTreeOptions): UseFileTreeResult;

package/dist/react/useFileTree.js

@@ -0,0 +1,59 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
+export function useFileTree({ client, podId, enabled = true, autoLoad = true, rootPath = "/", filesPerDirectory = 3, }) {
+    const [response, setResponse] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const refresh = useCallback(async (overrides = {}, signal) => {
+        if (!enabled) {
+            setResponse(null);
+            setError(null);
+            setIsLoading(false);
+            return null;
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const nextResponse = await scopedClient.files.tree({
+                rootPath: overrides.rootPath ?? rootPath,
+                filesPerDirectory: overrides.filesPerDirectory ?? filesPerDirectory,
+            });
+            if (signal?.aborted)
+                return null;
+            setResponse(nextResponse);
+            return nextResponse;
+        }
+        catch (refreshError) {
+            if (signal?.aborted)
+                return null;
+            setError(normalizeError(refreshError, "Failed to load file tree."));
+            setResponse(null);
+            return null;
+        }
+        finally {
+            if (!signal?.aborted)
+                setIsLoading(false);
+        }
+    }, [client, enabled, filesPerDirectory, podId, rootPath]);
+    useEffect(() => {
+        if (!enabled) {
+            setResponse(null);
+            setError(null);
+            setIsLoading(false);
+            return;
+        }
+        if (!autoLoad)
+            return;
+        const controller = new AbortController();
+        void refresh({}, controller.signal);
+        return () => controller.abort();
+    }, [autoLoad, enabled, refresh]);
+    return useMemo(() => ({
+        tree: response?.tree ?? null,
+        response,
+        isLoading,
+        error,
+        refresh,
+    }), [error, isLoading, refresh, response]);
+}

package/dist/react/useFiles.d.ts

@@ -0,0 +1,29 @@
+import type { LemmaClient } from "../client.js";
+import type { FileResponse } from "../types.js";
+export interface UseFilesOptions {
+    client: LemmaClient;
+    podId?: string;
+    enabled?: boolean;
+    autoLoad?: boolean;
+    limit?: number;
+    pageToken?: string;
+    directoryPath?: string;
+    parentId?: string;
+}
+export interface UseFilesResult {
+    files: FileResponse[];
+    nextPageToken: string | null;
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    error: Error | null;
+    refresh: (overrides?: {
+        limit?: number;
+        pageToken?: string;
+        directoryPath?: string;
+        parentId?: string;
+    }) => Promise<FileResponse[]>;
+    loadMore: (overrides?: {
+        limit?: number;
+    }) => Promise<FileResponse[]>;
+}
+export declare function useFiles({ client, podId, enabled, autoLoad, limit, pageToken, directoryPath, parentId, }: UseFilesOptions): UseFilesResult;

package/dist/react/useFiles.js

@@ -0,0 +1,90 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
+export function useFiles({ client, podId, enabled = true, autoLoad = true, limit = 100, pageToken, directoryPath = "/", parentId, }) {
+    const [files, setFiles] = useState([]);
+    const [nextPageToken, setNextPageToken] = useState(null);
+    const [isLoading, setIsLoading] = useState(false);
+    const [isLoadingMore, setIsLoadingMore] = useState(false);
+    const [error, setError] = useState(null);
+    const refresh = useCallback(async (overrides = {}, signal) => {
+        if (!enabled)
+            return [];
+        setIsLoading(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const response = await scopedClient.files.list({
+                limit: overrides.limit ?? limit,
+                pageToken: overrides.pageToken ?? pageToken,
+                directoryPath: overrides.directoryPath ?? directoryPath,
+                parentId: overrides.parentId ?? parentId,
+            });
+            if (signal?.aborted)
+                return [];
+            const nextFiles = response.items ?? [];
+            setFiles(nextFiles);
+            setNextPageToken(response.next_page_token ?? null);
+            return nextFiles;
+        }
+        catch (refreshError) {
+            if (signal?.aborted)
+                return [];
+            setError(normalizeError(refreshError, "Failed to load files."));
+            return [];
+        }
+        finally {
+            if (!signal?.aborted)
+                setIsLoading(false);
+        }
+    }, [client, directoryPath, enabled, limit, pageToken, parentId, 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.files.list({
+                limit: overrides.limit ?? limit,
+                pageToken: nextPageToken,
+                directoryPath,
+                parentId,
+            });
+            const moreFiles = response.items ?? [];
+            setFiles((previous) => [...previous, ...moreFiles]);
+            setNextPageToken(response.next_page_token ?? null);
+            return moreFiles;
+        }
+        catch (loadError) {
+            setError(normalizeError(loadError, "Failed to load more files."));
+            return [];
+        }
+        finally {
+            setIsLoadingMore(false);
+        }
+    }, [client, directoryPath, enabled, isLoading, isLoadingMore, limit, nextPageToken, parentId, podId]);
+    useEffect(() => {
+        if (!enabled) {
+            setFiles([]);
+            setNextPageToken(null);
+            setError(null);
+            setIsLoading(false);
+            setIsLoadingMore(false);
+            return;
+        }
+        if (!autoLoad)
+            return;
+        const controller = new AbortController();
+        void refresh({}, controller.signal);
+        return () => controller.abort();
+    }, [autoLoad, enabled, refresh]);
+    return useMemo(() => ({
+        files,
+        nextPageToken,
+        isLoading,
+        isLoadingMore,
+        error,
+        refresh,
+        loadMore,
+    }), [error, files, isLoading, isLoadingMore, loadMore, nextPageToken, refresh]);
+}

package/dist/react/useRecords.js

@@ -72,7 +72,10 @@ export function useRecords({ client, podId, tableName, filters, sort, limit = 20
         trimmedTableName,
     ]);
     const loadMore = useCallback(async (overrides = {}) => {
-        if (!isEnabled || !nextPageToken || isLoading || isLoadingMore) {
+        const loadedCount = records.length;
+        const canLoadWithCursor = Boolean(nextPageToken);
+        const canLoadWithOffset = loadedCount < total;
+        if (!isEnabled || isLoading || isLoadingMore || (!canLoadWithCursor && !canLoadWithOffset)) {
             return [];
         }
         setIsLoadingMore(true);
@@ -83,15 +86,15 @@ export function useRecords({ client, podId, tableName, filters, sort, limit = 20
                 filters: stableFilters,
                 sort: stableSort,
                 limit: overrides.limit ?? limit,
-                pageToken: nextPageToken,
-                offset: overrides.offset,
+                pageToken: overrides.pageToken ?? nextPageToken ?? undefined,
+                offset: overrides.offset ?? (nextPageToken ? undefined : (offset ?? 0) + loadedCount),
                 sortBy: overrides.sortBy ?? sortBy,
                 order: overrides.order ?? order,
                 params: overrides.params ?? stableParams,
             });
             const moreRecords = (response.items ?? []);
             setRecords((previous) => [...previous, ...moreRecords]);
-            setTotal(response.total ?? records.length + moreRecords.length);
+            setTotal(response.total ?? loadedCount + moreRecords.length);
             setNextPageToken(response.next_page_token ?? null);
             return moreRecords;
         }
@@ -103,7 +106,7 @@ export function useRecords({ client, podId, tableName, filters, sort, limit = 20
         finally {
             setIsLoadingMore(false);
         }
-    }, [client, isEnabled, isLoading, isLoadingMore, limit, nextPageToken, offset, order, podId, records.length, sortBy, stableFilters, stableParams, stableSort, trimmedTableName]);
+    }, [client, isEnabled, isLoading, isLoadingMore, limit, nextPageToken, offset, order, podId, records.length, sortBy, stableFilters, stableParams, stableSort, total, trimmedTableName]);
     useEffect(() => {
         if (!isEnabled) {
             setRecords([]);

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import type { AgentResponse, AssistantResponse, AvailableModels, ColumnSchema, ConversationMessageResponse, ConversationResponse, CreateAgentRequest, CreateAssistantRequest, CreateTaskRequest, DatastoreQueryResponse, FlowRunEntity, FlowResponse, FunctionRunResponse, IconUploadResponse, OrganizationInvitationResponse, OrganizationMemberResponse, OrganizationResponse, PodConfigResponse, PodJoinRequestCreateResponse, PodMemberResponse, PodResponse, TableResponse, TaskMessageResponse, TaskResponse, UpdateAgentRequest, UpdateAssistantRequest, UserResponse } from "./openapi_client/index.js";
+import type { AgentResponse, AssistantResponse, AvailableModels, ColumnSchema, ConversationMessageResponse, ConversationResponse, CreateAgentRequest, CreateAssistantRequest, CreateTaskRequest, DatastoreQueryResponse, DirectoryTreeNode, DirectoryTreeResponse, FileResponse, FileSearchResponse, FileSearchResultSchema, FlowRunEntity, FlowResponse, FunctionRunResponse, IconUploadResponse, OrganizationInvitationResponse, OrganizationMemberResponse, OrganizationResponse, PodConfigResponse, PodJoinRequestCreateResponse, PodMemberResponse, PodResponse, TableResponse, TaskMessageResponse, TaskResponse, UpdateAgentRequest, UpdateAssistantRequest, UserResponse } from "./openapi_client/index.js";
 /** Public ergonomic types. */
 export interface PageResult<T> {
     items: T[];
@@ -55,6 +55,11 @@ export type Workflow = FlowResponse;
 export type Table = TableResponse;
 export type TableColumn = ColumnSchema;
 export type DatastoreQueryResult = DatastoreQueryResponse;
+export type DatastoreFile = FileResponse;
+export type DatastoreFileSearchResponse = FileSearchResponse;
+export type DatastoreFileSearchResult = FileSearchResultSchema;
+export type DatastoreDirectoryTree = DirectoryTreeResponse;
+export type DatastoreDirectoryTreeNode = DirectoryTreeNode;
 export type Pod = PodResponse;
 export type PodConfig = PodConfigResponse;
 export type PodMember = PodMemberResponse;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lemma-sdk",
-  "version": "0.2.32",
+  "version": "0.2.33",
   "description": "Official TypeScript SDK for Lemma pod-scoped APIs",
   "type": "module",
   "main": "dist/index.js",
@@ -45,6 +45,7 @@
     "build:bundle": "tsc -p tsconfig.bundle.json && node ./scripts/build_browser_bundle.mjs",
     "clean": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true, maxRetries: 10, retryDelay: 100 })\"",
     "registry:build": "shadcn build ./registry.json -o ./public/r",
+    "registry:check": "npm run registry:build && node ./scripts/check_registry_blocks.mjs",
     "prepublishOnly": "npm run build",
     "release:check": "npm run build && npm_config_cache=.npm-cache npm pack --dry-run"
   },