lemma-sdk 0.2.43 → 0.2.45

package/dist/react/useAssistantSession.js

@@ -44,6 +44,77 @@ function isConversationRunningStatus(status) {
         return false;
     return normalized === "RUNNING" || normalized === "IN_PROGRESS" || normalized === "PROCESSING";
 }
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function parseMaybeJsonValue(value) {
+    if (typeof value !== "string")
+        return value;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return value;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return value;
+    }
+}
+function parseMaybeJsonObject(value) {
+    const parsed = parseMaybeJsonValue(value);
+    return isRecord(parsed) ? parsed : {};
+}
+function normalizeToolResult(value) {
+    const parsed = parseMaybeJsonValue(value);
+    if (isRecord(parsed))
+        return parsed;
+    if (Array.isArray(parsed))
+        return { output: parsed };
+    if (typeof parsed === "undefined" || parsed === null)
+        return {};
+    return { output: parsed };
+}
+function parseStreamingToolToken(token) {
+    const parsed = parseMaybeJsonValue(token);
+    if (!isRecord(parsed))
+        return null;
+    const toolName = [parsed.tool_name, parsed.toolName, parsed.name]
+        .find((value) => typeof value === "string" && value.trim().length > 0);
+    if (typeof toolName !== "string")
+        return null;
+    const rawToolCallId = [parsed.tool_call_id, parsed.toolCallId, parsed.call_id, parsed.id]
+        .find((value) => typeof value === "string" && value.trim().length > 0);
+    const rawArgs = parsed.tool_input ?? parsed.args ?? parsed.arguments ?? parsed.input;
+    const rawResult = parsed.tool_output ?? parsed.result ?? parsed.output;
+    const hasResult = typeof rawResult !== "undefined";
+    return {
+        ...(typeof rawToolCallId === "string" ? { toolCallId: rawToolCallId } : {}),
+        toolName,
+        args: parseMaybeJsonObject(rawArgs),
+        state: hasResult ? "result" : "call",
+        ...(hasResult ? { result: normalizeToolResult(rawResult) } : {}),
+    };
+}
+function parsePartialStreamingToolToken(token) {
+    const toolNameMatch = /"(?:tool_name|toolName|name)"\s*:\s*"((?:\\.|[^"\\])*)"/.exec(token);
+    if (!toolNameMatch?.[1])
+        return null;
+    const idMatch = /"(?:tool_call_id|toolCallId|call_id|id)"\s*:\s*"((?:\\.|[^"\\])*)"/.exec(token);
+    const unescapeJsonString = (value) => {
+        try {
+            return JSON.parse(`"${value}"`);
+        }
+        catch {
+            return value;
+        }
+    };
+    return {
+        ...(idMatch?.[1] ? { toolCallId: unescapeJsonString(idMatch[1]) } : {}),
+        toolName: unescapeJsonString(toolNameMatch[1]),
+        args: {},
+        state: "call",
+    };
+}
 function resolveResumeInput(input) {
     if (typeof input === "string" || input === null) {
         return { conversationId: input };
@@ -57,12 +128,14 @@ export function useAssistantSession(options) {
     const [status, setStatus] = useState(undefined);
     const [messages, setMessages] = useState([]);
     const [streamingText, setStreamingText] = useState("");
+    const [streamingTool, setStreamingTool] = useState(null);
     const [isStreaming, setIsStreaming] = useState(false);
     const [error, setError] = useState(null);
     const abortRef = useRef(null);
     const conversationIdRef = useRef(externalConversationId);
     const statusRef = useRef(undefined);
     const streamingTextRef = useRef("");
+    const streamingToolTokenRef = useRef("");
     const autoResumedKeyRef = useRef(null);
     const autoLoadInFlightKeyRef = useRef(null);
     const lastAutoLoadedKeyRef = useRef(null);
@@ -70,6 +143,9 @@ export function useAssistantSession(options) {
     const onStatusRef = useRef(onStatus);
     const onMessageRef = useRef(onMessage);
     const onErrorRef = useRef(onError);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const consumeRef = useRef(null);
+    const streamReconnectCountRef = useRef(0);
     const setConversationId = useCallback((nextConversationId) => {
         abortRef.current?.abort();
         abortRef.current = null;
@@ -82,6 +158,7 @@ export function useAssistantSession(options) {
             lastAutoLoadedKeyRef.current = null;
             streamingTextRef.current = "";
             setStreamingText("");
+            setStreamingTool(null);
             setConversation(null);
             setStatus(undefined);
             statusRef.current = undefined;
@@ -129,6 +206,10 @@ export function useAssistantSession(options) {
         streamingTextRef.current = "";
         setStreamingText("");
     }, []);
+    const clearStreamingTool = useCallback(() => {
+        streamingToolTokenRef.current = "";
+        setStreamingTool(null);
+    }, []);
     const appendStreamingToken = useCallback((token) => {
         if (!token)
             return;
@@ -166,8 +247,6 @@ export function useAssistantSession(options) {
             const response = await scopedClient.conversations.list({
                 pod_id: scope.podId ?? undefined,
                 agent_name: scope.agentName ?? undefined,
-                status: input.status ?? undefined,
-                type: input.type,
                 limit: input.limit,
                 page_token: input.pageToken,
             });
@@ -199,7 +278,6 @@ export function useAssistantSession(options) {
                     ? defaultInstructions ?? undefined
                     : input.instructions,
                 metadata: input.metadata ?? undefined,
-                type: input.type,
                 pod_id: input.podId ?? defaultPodId ?? scopedClient.podId ?? undefined,
                 agent_name: input.agentName
                     ?? input.assistantName
@@ -211,6 +289,9 @@ export function useAssistantSession(options) {
                 model: typeof input.model === "undefined"
                     ? undefined
                     : input.model,
+                agent_runtime: typeof input.agentRuntime === "undefined"
+                    ? undefined
+                    : input.agentRuntime,
             };
             const created = await scopedClient.conversations.create(payload);
             if (input.setActive !== false) {
@@ -314,8 +395,37 @@ export function useAssistantSession(options) {
                 const payload = parseSSEJson(event);
                 onEventRef.current?.(event, payload);
                 const parsed = parseAssistantStreamEvent(payload);
+                if (parsed.error) {
+                    const streamError = new Error(parsed.error);
+                    setError(streamError);
+                    onErrorRef.current?.(streamError);
+                    setConversationStatus(parsed.status ?? "FAILED");
+                    sawTerminalStatus = true;
+                    clearStreamingText();
+                    clearStreamingTool();
+                    continue;
+                }
                 if (parsed.token) {
-                    appendStreamingToken(parsed.token);
+                    if (parsed.tokenKind === "tool") {
+                        streamingToolTokenRef.current += parsed.token;
+                        const tool = parseStreamingToolToken(streamingToolTokenRef.current)
+                            || parsePartialStreamingToolToken(streamingToolTokenRef.current);
+                        if (tool?.state === "call") {
+                            setStreamingTool(tool);
+                            if (parseStreamingToolToken(streamingToolTokenRef.current)) {
+                                streamingToolTokenRef.current = "";
+                            }
+                        }
+                        else if (tool?.state === "result") {
+                            setStreamingTool((current) => (current?.toolCallId && current.toolCallId === tool.toolCallId
+                                ? { ...current, ...tool }
+                                : current));
+                            streamingToolTokenRef.current = "";
+                        }
+                    }
+                    else if (!parsed.tokenKind || parsed.tokenKind === "text") {
+                        appendStreamingToken(parsed.token);
+                    }
                 }
                 if (parsed.message) {
                     setMessages((previous) => upsertConversationMessage(previous, parsed.message));
@@ -325,6 +435,7 @@ export function useAssistantSession(options) {
                         : "";
                     if (role === "assistant" || role === "tool") {
                         clearStreamingText();
+                        clearStreamingTool();
                     }
                 }
                 if (parsed.status) {
@@ -332,14 +443,38 @@ export function useAssistantSession(options) {
                     if (!isConversationRunningStatus(parsed.status)) {
                         sawTerminalStatus = true;
                         clearStreamingText();
+                        clearStreamingTool();
                     }
                 }
             }
             if (!controller.signal.aborted) {
                 if (!sawTerminalStatus && isConversationRunningStatus(statusRef.current)) {
+                    const reconId = streamConversationId ?? conversationId;
+                    if (reconId && streamReconnectCountRef.current < 3) {
+                        streamReconnectCountRef.current += 1;
+                        const delay = Math.pow(2, streamReconnectCountRef.current - 1) * 1000;
+                        await new Promise((r) => setTimeout(r, delay));
+                        if (!controller.signal.aborted && isConversationRunningStatus(statusRef.current)) {
+                            try {
+                                const scope = normalizeScope(client, defaultScope);
+                                const scopedClient = applyPodScope(client, scope.podId);
+                                const newStream = await scopedClient.conversations.resumeStream(reconId, {
+                                    pod_id: scope.podId ?? undefined,
+                                    signal: controller.signal,
+                                });
+                                // Sync any messages delivered while the stream was dropped
+                                await loadMessages({ conversationId: reconId, limit: 100 });
+                                streamReconnectCountRef.current = 0;
+                                return consumeRef.current({ stream: newStream, controller, streamConversationId: reconId, syncAfterStream });
+                            }
+                            catch { /* fall through to WAITING */ }
+                        }
+                    }
+                    streamReconnectCountRef.current = 0;
                     setConversationStatus("WAITING");
                 }
                 clearStreamingText();
+                clearStreamingTool();
                 const shouldSync = syncAfterStream ?? syncOnTurnEnd;
                 const syncConversationId = streamConversationId ?? conversationId;
                 if (shouldSync && syncConversationId) {
@@ -363,13 +498,19 @@ export function useAssistantSession(options) {
         }
     }, [
         appendStreamingToken,
+        clearStreamingTool,
         clearStreamingText,
+        client,
         conversationId,
+        defaultScope,
         loadMessages,
         refreshConversation,
         setConversationStatus,
         syncOnTurnEnd,
     ]);
+    useEffect(() => {
+        consumeRef.current = consume;
+    }, [consume]);
     const ensureConversation = useCallback(async (overrideConversationId) => {
         const existingId = overrideConversationId ?? conversationId;
         if (existingId) {
@@ -576,6 +717,7 @@ export function useAssistantSession(options) {
         finalOutput,
         finalOutputText,
         streamingText,
+        streamingTool,
         isStreaming,
         error,
         setConversationId,

package/dist/react/useBulkRecords.d.ts

@@ -1,20 +1,20 @@
 import type { LemmaClient } from "../client.js";
-import type { DatastoreMessageResponse } from "../types.js";
+import type { DatastoreCountResponse } from "../types.js";
 export interface UseBulkRecordsOptions {
     client: LemmaClient;
     podId?: string;
     tableName: string;
     enabled?: boolean;
-    onSuccess?: (response: DatastoreMessageResponse) => void;
+    onSuccess?: (response: DatastoreCountResponse) => void;
     onError?: (error: unknown) => void;
 }
 export interface UseBulkRecordsResult {
     isSubmitting: boolean;
     error: Error | null;
     lastMessage: string | null;
-    createMany: (records: Record<string, unknown>[]) => Promise<DatastoreMessageResponse | null>;
-    updateMany: (records: Record<string, unknown>[]) => Promise<DatastoreMessageResponse | null>;
-    deleteMany: (recordIds: Array<string | number>) => Promise<DatastoreMessageResponse | null>;
+    createMany: (records: Record<string, unknown>[]) => Promise<DatastoreCountResponse | null>;
+    updateMany: (records: Record<string, unknown>[]) => Promise<DatastoreCountResponse | null>;
+    deleteMany: (recordIds: Array<string | number>) => Promise<DatastoreCountResponse | null>;
     reset: () => void;
 }
 export declare function useBulkRecords({ client, podId, tableName, enabled, onSuccess, onError, }: UseBulkRecordsOptions): UseBulkRecordsResult;

package/dist/react/useBulkRecords.js

@@ -10,7 +10,7 @@ export function useBulkRecords({ client, podId, tableName, enabled = true, onSuc
     useEffect(() => { onErrorRef.current = onError; }, [onError]);
     const trimmedTableName = tableName.trim();
     const isEnabled = enabled && trimmedTableName.length > 0;
-    const runBulkOperation = useCallback(async (action, fallbackError) => {
+    const runBulkOperation = useCallback(async (action, fallbackError, describe) => {
         if (!isEnabled) {
             return null;
         }
@@ -19,7 +19,7 @@ export function useBulkRecords({ client, podId, tableName, enabled = true, onSuc
         try {
             const scopedClient = resolvePodClient(client, podId);
             const response = await action(scopedClient);
-            setLastMessage(response.message ?? null);
+            setLastMessage(describe(response.count));
             onSuccessRef.current?.(response);
             return response;
         }
@@ -36,17 +36,17 @@ export function useBulkRecords({ client, podId, tableName, enabled = true, onSuc
     const createMany = useCallback(async (records) => {
         if (records.length === 0)
             return null;
-        return runBulkOperation((scopedClient) => scopedClient.records.bulk.create(trimmedTableName, records), "Failed to bulk create records.");
+        return runBulkOperation((scopedClient) => scopedClient.records.bulk.create(trimmedTableName, records), "Failed to bulk create records.", (count) => `${count} record${count === 1 ? "" : "s"} created.`);
     }, [runBulkOperation, trimmedTableName]);
     const updateMany = useCallback(async (records) => {
         if (records.length === 0)
             return null;
-        return runBulkOperation((scopedClient) => scopedClient.records.bulk.update(trimmedTableName, records), "Failed to bulk update records.");
+        return runBulkOperation((scopedClient) => scopedClient.records.bulk.update(trimmedTableName, records), "Failed to bulk update records.", (count) => `${count} record${count === 1 ? "" : "s"} updated.`);
     }, [runBulkOperation, trimmedTableName]);
     const deleteMany = useCallback(async (recordIds) => {
         if (recordIds.length === 0)
             return null;
-        return runBulkOperation((scopedClient) => scopedClient.records.bulk.delete(trimmedTableName, recordIds), "Failed to bulk delete records.");
+        return runBulkOperation((scopedClient) => scopedClient.records.bulk.delete(trimmedTableName, recordIds), "Failed to bulk delete records.", (count) => `${count} record${count === 1 ? "" : "s"} deleted.`);
     }, [runBulkOperation, trimmedTableName]);
     const reset = useCallback(() => {
         setError(null);

package/dist/react/useConversations.d.ts

@@ -1,6 +1,4 @@
 import type { LemmaClient } from "../client.js";
-import type { ConversationStatus } from "../openapi_client/models/ConversationStatus.js";
-import type { ConversationType } from "../openapi_client/models/ConversationType.js";
 import type { Conversation } from "../types.js";
 import { type CreateConversationInput } from "./useAssistantSession.js";
 export interface UseConversationsOptions {
@@ -21,8 +19,6 @@ export interface UseConversationsOptions {
     autoSelectFirst?: boolean;
     limit?: number;
     pageToken?: string;
-    status?: ConversationStatus | `${ConversationStatus}` | null;
-    type?: ConversationType | `${ConversationType}` | null;
     initialConversationId?: string | null;
 }
 export interface UseConversationsResult {
@@ -49,8 +45,6 @@ export interface UseConversationsResult {
     refresh: (overrides?: {
         limit?: number;
         pageToken?: string;
-        status?: ConversationStatus | `${ConversationStatus}` | null;
-        type?: ConversationType | `${ConversationType}` | null;
     }) => Promise<Conversation[]>;
     loadMore: (overrides?: {
         limit?: number;
@@ -59,4 +53,4 @@ export interface UseConversationsResult {
     createAndSelectConversation: (input?: Omit<CreateConversationInput, "setActive">) => Promise<Conversation>;
     ensureConversation: (input?: Omit<CreateConversationInput, "setActive">) => Promise<Conversation>;
 }
-export declare function useConversations({ client, podId, agentName, assistantName, assistantId, organizationId, enabled, autoLoad, autoSelectFirst, limit, pageToken, status, type, initialConversationId, }: UseConversationsOptions): UseConversationsResult;
+export declare function useConversations({ client, podId, agentName, assistantName, assistantId, organizationId, enabled, autoLoad, autoSelectFirst, limit, pageToken, initialConversationId, }: UseConversationsOptions): UseConversationsResult;

package/dist/react/useConversations.js

@@ -8,7 +8,7 @@ function sortConversationsByUpdatedAt(conversations) {
         return bTime - aTime;
     });
 }
-export function useConversations({ client, podId, agentName, assistantName, assistantId, organizationId, enabled = true, autoLoad = true, autoSelectFirst = true, limit = 20, pageToken, status, type, initialConversationId = null, }) {
+export function useConversations({ client, podId, agentName, assistantName, assistantId, organizationId, enabled = true, autoLoad = true, autoSelectFirst = true, limit = 20, pageToken, initialConversationId = null, }) {
     const [conversations, setConversations] = useState([]);
     const [total, setTotal] = useState(0);
     const [nextPageToken, setNextPageToken] = useState(null);
@@ -21,9 +21,7 @@ export function useConversations({ client, podId, agentName, assistantName, assi
         assistantName: assistantName ?? null,
         assistantId: assistantId ?? null,
         organizationId: organizationId ?? null,
-        status: status ?? null,
-        type: type ?? null,
-    }), [agentName, assistantId, assistantName, organizationId, podId, status, type]);
+    }), [agentName, assistantId, assistantName, organizationId, podId]);
     const { error, listConversations, createConversation: sessionCreateConversation, } = useAssistantSession({
         client,
         podId,
@@ -46,8 +44,6 @@ export function useConversations({ client, podId, agentName, assistantName, assi
             const response = await listConversations({
                 limit: overrides.limit ?? limit,
                 pageToken: overrides.pageToken ?? pageToken,
-                status: overrides.status ?? status,
-                type: overrides.type ?? type,
             });
             const nextConversations = sortConversationsByUpdatedAt(response.items ?? []);
             setConversations(nextConversations);
@@ -67,7 +63,7 @@ export function useConversations({ client, podId, agentName, assistantName, assi
         finally {
             setIsLoading(false);
         }
-    }, [autoSelectFirst, enabled, initialConversationId, limit, listConversations, pageToken, status, type]);
+    }, [autoSelectFirst, enabled, initialConversationId, limit, listConversations, pageToken]);
     const loadMore = useCallback(async (overrides = {}) => {
         if (!enabled || !nextPageToken || isLoading || isLoadingMore) {
             return [];
@@ -77,8 +73,6 @@ export function useConversations({ client, podId, agentName, assistantName, assi
             const response = await listConversations({
                 limit: overrides.limit ?? limit,
                 pageToken: nextPageToken,
-                status,
-                type,
             });
             const moreConversations = sortConversationsByUpdatedAt(response.items ?? []);
             setConversations((previous) => [...previous, ...moreConversations]);
@@ -93,7 +87,7 @@ export function useConversations({ client, podId, agentName, assistantName, assi
         finally {
             setIsLoadingMore(false);
         }
-    }, [conversations.length, enabled, isLoading, isLoadingMore, limit, listConversations, nextPageToken, status, type]);
+    }, [conversations.length, enabled, isLoading, isLoadingMore, limit, listConversations, nextPageToken]);
     const createConversation = useCallback(async (input = {}) => {
         const createdConversation = await sessionCreateConversation({
             ...input,

package/dist/react/useCreateFolder.d.ts

@@ -1,15 +1,13 @@
 import type { LemmaClient } from "../client.js";
-import type { DatastoreFileNamespace, FileResponse } from "../types.js";
+import type { FileResponse } from "../types.js";
 export interface CreateFolderInput {
     directoryPath?: string;
     parentId?: string;
     description?: string;
-    namespace?: DatastoreFileNamespace | null;
 }
 export interface UseCreateFolderOptions {
     client: LemmaClient;
     podId?: string;
-    namespace?: DatastoreFileNamespace | null;
     enabled?: boolean;
     onSuccess?: (folder: FileResponse) => void;
     onError?: (error: unknown) => void;
@@ -21,4 +19,4 @@ export interface UseCreateFolderResult<TFile extends FileResponse = FileResponse
     createFolder: (name: string, options?: CreateFolderInput) => Promise<TFile | null>;
     reset: () => void;
 }
-export declare function useCreateFolder<TFile extends FileResponse = FileResponse>({ client, podId, namespace, enabled, onSuccess, onError, }: UseCreateFolderOptions): UseCreateFolderResult<TFile>;
+export declare function useCreateFolder<TFile extends FileResponse = FileResponse>({ client, podId, enabled, onSuccess, onError, }: UseCreateFolderOptions): UseCreateFolderResult<TFile>;

package/dist/react/useCreateFolder.js

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { normalizeError, resolvePodClient } from "./utils.js";
-export function useCreateFolder({ client, podId, namespace, enabled = true, onSuccess, onError, }) {
+export function useCreateFolder({ client, podId, enabled = true, onSuccess, onError, }) {
     const [createdFolder, setCreatedFolder] = useState(null);
     const [isSubmitting, setIsSubmitting] = useState(false);
     const [error, setError] = useState(null);
@@ -19,7 +19,6 @@ export function useCreateFolder({ client, podId, namespace, enabled = true, onSu
             const scopedClient = resolvePodClient(client, podId);
             const nextFolder = await scopedClient.files.folder.create(trimmedName, {
                 ...options,
-                namespace: options.namespace ?? namespace,
             });
             setCreatedFolder(nextFolder);
             onSuccessRef.current?.(nextFolder);
@@ -34,7 +33,7 @@ export function useCreateFolder({ client, podId, namespace, enabled = true, onSu
         finally {
             setIsSubmitting(false);
         }
-    }, [client, enabled, namespace, podId]);
+    }, [client, enabled, podId]);
     const reset = useCallback(() => {
         setCreatedFolder(null);
         setError(null);

package/dist/react/useCreateRecord.d.ts

@@ -1,5 +1,5 @@
 import type { LemmaClient } from "../client.js";
-import type { FunctionRun, RecordResponse } from "../types.js";
+import type { FunctionRun } from "../types.js";
 /**
  * React hook for creating a single record. Manages loading/error state and
  * exposes a `create` function you can call from event handlers.
@@ -35,7 +35,7 @@ export interface UseCreateRecordOptions {
     createVia?: "direct" | "function";
     /** Function name to run when `createVia` is `"function"`. Falls back to `tableName` if omitted. */
     createFunctionName?: string;
-    onSuccess?: (record: Record<string, unknown>, response: RecordResponse | FunctionRun) => void;
+    onSuccess?: (record: Record<string, unknown>, response: Record<string, unknown> | FunctionRun) => void;
     onError?: (error: unknown) => void;
 }
 export interface UseCreateRecordResult<TRecord extends Record<string, unknown> = Record<string, unknown>> {

package/dist/react/useCreateRecord.js

@@ -29,7 +29,7 @@ export function useCreateRecord({ client, podId, tableName, enabled = true, crea
                 return nextRecord;
             }
             const response = await scopedClient.records.create(trimmedTableName, data);
-            const nextRecord = (response.data ?? null);
+            const nextRecord = (response ?? null);
             setCreatedRecord(nextRecord);
             if (nextRecord) {
                 onSuccessRef.current?.(nextRecord, response);

package/dist/react/useDeleteFile.d.ts

@@ -1,10 +1,8 @@
 import type { LemmaClient } from "../client.js";
-import type { DatastoreFileNamespace } from "../types.js";
 export interface UseDeleteFileOptions {
     client: LemmaClient;
     podId?: string;
     path?: string | null;
-    namespace?: DatastoreFileNamespace | null;
     enabled?: boolean;
     onSuccess?: (path: string) => void;
     onError?: (error: unknown) => void;
@@ -15,8 +13,7 @@ export interface UseDeleteFileResult {
     error: Error | null;
     remove: (overrides?: {
         path?: string | null;
-        namespace?: DatastoreFileNamespace | null;
     }) => Promise<boolean>;
     reset: () => void;
 }
-export declare function useDeleteFile({ client, podId, path, namespace, enabled, onSuccess, onError, }: UseDeleteFileOptions): UseDeleteFileResult;
+export declare function useDeleteFile({ client, podId, path, enabled, onSuccess, onError, }: UseDeleteFileOptions): UseDeleteFileResult;

package/dist/react/useDeleteFile.js

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { normalizeError, resolvePodClient } from "./utils.js";
-export function useDeleteFile({ client, podId, path = null, namespace, enabled = true, onSuccess, onError, }) {
+export function useDeleteFile({ client, podId, path = null, enabled = true, onSuccess, onError, }) {
     const [deletedPath, setDeletedPath] = useState(null);
     const [isSubmitting, setIsSubmitting] = useState(false);
     const [error, setError] = useState(null);
@@ -21,7 +21,7 @@ export function useDeleteFile({ client, podId, path = null, namespace, enabled =
         setError(null);
         try {
             const scopedClient = resolvePodClient(client, podId);
-            await scopedClient.files.delete(nextPath, { namespace: overrides.namespace ?? namespace });
+            await scopedClient.files.delete(nextPath);
             setDeletedPath(nextPath);
             onSuccessRef.current?.(nextPath);
             return true;
@@ -35,7 +35,7 @@ export function useDeleteFile({ client, podId, path = null, namespace, enabled =
         finally {
             setIsSubmitting(false);
         }
-    }, [client, isEnabled, namespace, podId, trimmedPath]);
+    }, [client, isEnabled, podId, trimmedPath]);
     const reset = useCallback(() => {
         setDeletedPath(null);
         setError(null);

package/dist/react/useDeleteRecord.d.ts

@@ -1,12 +1,11 @@
 import type { LemmaClient } from "../client.js";
-import type { DatastoreMessageResponse } from "../types.js";
 export interface UseDeleteRecordOptions {
     client: LemmaClient;
     podId?: string;
     tableName: string;
     recordId?: string | null;
     enabled?: boolean;
-    onSuccess?: (response: DatastoreMessageResponse) => void;
+    onSuccess?: () => void;
     onError?: (error: unknown) => void;
 }
 export interface UseDeleteRecordResult {

package/dist/react/useDeleteRecord.js

@@ -22,9 +22,9 @@ export function useDeleteRecord({ client, podId, tableName, recordId = null, ena
         setError(null);
         try {
             const scopedClient = resolvePodClient(client, podId);
-            const response = await scopedClient.records.delete(trimmedTableName, nextRecordId);
-            setLastMessage(response.message ?? "Record deleted.");
-            onSuccessRef.current?.(response);
+            await scopedClient.records.delete(trimmedTableName, nextRecordId);
+            setLastMessage("Record deleted.");
+            onSuccessRef.current?.();
             return true;
         }
         catch (mutationError) {

package/dist/react/useFile.d.ts

@@ -1,10 +1,9 @@
 import type { LemmaClient } from "../client.js";
-import type { DatastoreFileNamespace, FileResponse } from "../types.js";
+import type { FileResponse } from "../types.js";
 export interface UseFileOptions {
     client: LemmaClient;
     podId?: string;
     path?: string | null;
-    namespace?: DatastoreFileNamespace | null;
     enabled?: boolean;
     autoLoad?: boolean;
 }
@@ -14,7 +13,6 @@ export interface UseFileResult {
     error: Error | null;
     refresh: (overrides?: {
         path?: string | null;
-        namespace?: DatastoreFileNamespace | null;
     }) => Promise<FileResponse | null>;
 }
-export declare function useFile({ client, podId, path, namespace, enabled, autoLoad, }: UseFileOptions): UseFileResult;
+export declare function useFile({ client, podId, path, enabled, autoLoad, }: UseFileOptions): UseFileResult;

package/dist/react/useFile.js

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { normalizeError, resolvePodClient } from "./utils.js";
-export function useFile({ client, podId, path = null, namespace, enabled = true, autoLoad = true, }) {
+export function useFile({ client, podId, path = null, enabled = true, autoLoad = true, }) {
     const [file, setFile] = useState(null);
     const [isLoading, setIsLoading] = useState(false);
     const [error, setError] = useState(null);
@@ -18,7 +18,7 @@ export function useFile({ client, podId, path = null, namespace, enabled = true,
         setError(null);
         try {
             const scopedClient = resolvePodClient(client, podId);
-            const nextFile = await scopedClient.files.get(nextPath, { namespace: overrides.namespace ?? namespace });
+            const nextFile = await scopedClient.files.get(nextPath);
             if (signal?.aborted)
                 return null;
             setFile(nextFile);
@@ -35,7 +35,7 @@ export function useFile({ client, podId, path = null, namespace, enabled = true,
             if (!signal?.aborted)
                 setIsLoading(false);
         }
-    }, [client, enabled, namespace, podId, trimmedPath]);
+    }, [client, enabled, podId, trimmedPath]);
     useEffect(() => {
         if (!isEnabled) {
             setFile(null);

package/dist/react/useFilePreview.d.ts

@@ -1,5 +1,4 @@
 import type { LemmaClient } from "../client.js";
-import type { DatastoreFileNamespace } from "../types.js";
 export type FilePreviewMode = "rendered" | "artifact";
 export interface UseFilePreviewOptions {
     client: LemmaClient;
@@ -9,7 +8,6 @@ export interface UseFilePreviewOptions {
     autoLoad?: boolean;
     mode?: FilePreviewMode;
     artifact?: string;
-    namespace?: DatastoreFileNamespace | null;
 }
 export interface UseFilePreviewResult {
     content: string | null;
@@ -20,7 +18,6 @@ export interface UseFilePreviewResult {
         path?: string | null;
         mode?: FilePreviewMode;
         artifact?: string;
-        namespace?: DatastoreFileNamespace | null;
     }) => Promise<string | null>;
 }
-export declare function useFilePreview({ client, podId, path, enabled, autoLoad, mode, artifact, namespace, }: UseFilePreviewOptions): UseFilePreviewResult;
+export declare function useFilePreview({ client, podId, path, enabled, autoLoad, mode, artifact, }: UseFilePreviewOptions): UseFilePreviewResult;