lemma-sdk 0.2.44 → 0.2.45

package/dist/openapi_client/services/WorkflowsService.d.ts

@@ -1,16 +1,17 @@
 import type { FlowDetailResponse } from '../models/FlowDetailResponse.js';
-import type { FlowRunEntity } from '../models/FlowRunEntity.js';
 import type { WorkflowCreateRequest } from '../models/WorkflowCreateRequest.js';
 import type { WorkflowGraphUpdateRequest } from '../models/WorkflowGraphUpdateRequest.js';
 import type { WorkflowListResponse } from '../models/WorkflowListResponse.js';
+import type { WorkflowRunFormSubmitRequest } from '../models/WorkflowRunFormSubmitRequest.js';
 import type { WorkflowRunListResponse } from '../models/WorkflowRunListResponse.js';
+import type { WorkflowRunResponse } from '../models/WorkflowRunResponse.js';
 import type { WorkflowRunWaitAssignmentListResponse } from '../models/WorkflowRunWaitAssignmentListResponse.js';
 import type { WorkflowUpdateRequest } from '../models/WorkflowUpdateRequest.js';
 import type { CancelablePromise } from '../core/CancelablePromise.js';
 export declare class WorkflowsService {
     /**
      * List Workflow Runs Waiting For Current User
-     * List active human form waits assigned to the current pod member.
+     * The current user's approval queue: active form waits assigned to them, with the owning run.
      * @param podId
      * @param limit
      * @param pageToken
@@ -20,23 +21,32 @@ export declare class WorkflowsService {
     static workflowRunWaitingAssignedToMe(podId: string, limit?: number, pageToken?: (string | null)): CancelablePromise<WorkflowRunWaitAssignmentListResponse>;
     /**
      * Get Workflow Run
-     * Get current state, context, and step history of a workflow run.
+     * Get current state, context, step history, and the active wait (when WAITING) of a workflow run.
      * @param podId
      * @param runId
-     * @returns FlowRunEntity Successful Response
+     * @returns WorkflowRunResponse Successful Response
      * @throws ApiError
      */
-    static workflowRunGet(podId: string, runId: string): CancelablePromise<FlowRunEntity>;
+    static workflowRunGet(podId: string, runId: string): CancelablePromise<WorkflowRunResponse>;
     /**
-     * Resume Workflow Run
-     * Resume a run in WAITING or EXECUTING state. The payload is written back into the current waiting node output and execution continues.
+     * Cancel Workflow Run
+     * Cancel a non-terminal run. The active wait (if any) is cancelled in the same transaction; late completion events for cancelled waits are dropped. Cancelling a terminal run returns 409.
+     * @param podId
+     * @param runId
+     * @returns WorkflowRunResponse Successful Response
+     * @throws ApiError
+     */
+    static workflowRunCancel(podId: string, runId: string): CancelablePromise<WorkflowRunResponse>;
+    /**
+     * Submit Workflow Run Form
+     * Submit the form the run is waiting on. `node_id` must match the run's active HUMAN wait (409 when the run is not waiting on a form, 422 on node mismatch, 403 when the wait is assigned to someone else). The submitted `inputs` become the form node's output, available to later nodes as `<node_id>.<field>`.
      * @param podId
      * @param runId
      * @param requestBody
-     * @returns FlowRunEntity Successful Response
+     * @returns WorkflowRunResponse Successful Response
      * @throws ApiError
      */
-    static workflowRunResume(podId: string, runId: string, requestBody: Record<string, any>): CancelablePromise<FlowRunEntity>;
+    static workflowRunFormSubmit(podId: string, runId: string, requestBody: WorkflowRunFormSubmitRequest): CancelablePromise<WorkflowRunResponse>;
     /**
      * Visualize Workflow Run
      * Render an HTML view of a run overlaid on its workflow graph.
@@ -46,17 +56,6 @@ export declare class WorkflowsService {
      * @throws ApiError
      */
     static workflowRunVisualize(podId: string, runId: string): CancelablePromise<string>;
-    /**
-     * List Workflow Runs
-     * List recent runs for a given workflow.
-     * @param podId
-     * @param workflowName
-     * @param limit
-     * @param pageToken
-     * @returns WorkflowRunListResponse Successful Response
-     * @throws ApiError
-     */
-    static workflowRunList(podId: string, workflowName: string, limit?: number, pageToken?: (string | null)): CancelablePromise<WorkflowRunListResponse>;
     /**
      * List Workflows
      * List all workflows in a pod.
@@ -69,7 +68,7 @@ export declare class WorkflowsService {
     static workflowList(podId: string, limit?: number, pageToken?: (string | null)): CancelablePromise<WorkflowListResponse>;
     /**
      * Create Workflow
-     * Create a workflow definition. Use this before uploading graph nodes/edges with `workflow.graph.update`.
+     * Create a workflow definition. The graph (`nodes`/`edges`) can be included in this call to create a ready-to-run workflow in one step, or omitted to create a shell and upload the graph later with `workflow.graph.update`.
      * @param podId
      * @param requestBody
      * @returns FlowDetailResponse Successful Response
@@ -115,15 +114,25 @@ export declare class WorkflowsService {
      */
     static workflowGraphUpdate(podId: string, workflowName: string, requestBody: WorkflowGraphUpdateRequest): CancelablePromise<FlowDetailResponse>;
     /**
-     * Start Workflow
-     * Start a new workflow run. For event/scheduled/datastore starts, the request body is treated as initial trigger payload and merged into execution context.
+     * List Workflow Runs
+     * List recent runs for a given workflow.
      * @param podId
      * @param workflowName
-     * @param requestBody
-     * @returns FlowRunEntity Successful Response
+     * @param limit
+     * @param pageToken
+     * @returns WorkflowRunListResponse Successful Response
+     * @throws ApiError
+     */
+    static workflowRunList(podId: string, workflowName: string, limit?: number, pageToken?: (string | null)): CancelablePromise<WorkflowRunListResponse>;
+    /**
+     * Create Workflow Run
+     * Create a new run for this workflow. Takes no request body: if the workflow's entry node is a FORM node the run is created WAITING on it (see `active_wait` in the response) and input is submitted via `workflow.run.form.submit`; otherwise the run executes immediately. Trigger payloads for scheduled/event/datastore starts are supplied by the platform, not through this endpoint.
+     * @param podId
+     * @param workflowName
+     * @returns WorkflowRunResponse Successful Response
      * @throws ApiError
      */
-    static workflowStart(podId: string, workflowName: string, requestBody: Record<string, any>): CancelablePromise<FlowRunEntity>;
+    static workflowRunCreate(podId: string, workflowName: string): CancelablePromise<WorkflowRunResponse>;
     /**
      * Visualize Workflow
      * Render an HTML visualization for debugging workflow graph structure.

package/dist/openapi_client/services/WorkflowsService.js

@@ -3,7 +3,7 @@ import { request as __request } from '../core/request.js';
 export class WorkflowsService {
     /**
      * List Workflow Runs Waiting For Current User
-     * List active human form waits assigned to the current pod member.
+     * The current user's approval queue: active form waits assigned to them, with the owning run.
      * @param podId
      * @param limit
      * @param pageToken
@@ -28,10 +28,10 @@ export class WorkflowsService {
     }
     /**
      * Get Workflow Run
-     * Get current state, context, and step history of a workflow run.
+     * Get current state, context, step history, and the active wait (when WAITING) of a workflow run.
      * @param podId
      * @param runId
-     * @returns FlowRunEntity Successful Response
+     * @returns WorkflowRunResponse Successful Response
      * @throws ApiError
      */
     static workflowRunGet(podId, runId) {
@@ -48,71 +48,65 @@ export class WorkflowsService {
         });
     }
     /**
-     * Resume Workflow Run
-     * Resume a run in WAITING or EXECUTING state. The payload is written back into the current waiting node output and execution continues.
+     * Cancel Workflow Run
+     * Cancel a non-terminal run. The active wait (if any) is cancelled in the same transaction; late completion events for cancelled waits are dropped. Cancelling a terminal run returns 409.
      * @param podId
      * @param runId
-     * @param requestBody
-     * @returns FlowRunEntity Successful Response
+     * @returns WorkflowRunResponse Successful Response
      * @throws ApiError
      */
-    static workflowRunResume(podId, runId, requestBody) {
+    static workflowRunCancel(podId, runId) {
         return __request(OpenAPI, {
             method: 'POST',
-            url: '/pods/{pod_id}/workflow-runs/{run_id}/resume',
+            url: '/pods/{pod_id}/workflow-runs/{run_id}/cancel',
             path: {
                 'pod_id': podId,
                 'run_id': runId,
             },
-            body: requestBody,
-            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
     /**
-     * Visualize Workflow Run
-     * Render an HTML view of a run overlaid on its workflow graph.
+     * Submit Workflow Run Form
+     * Submit the form the run is waiting on. `node_id` must match the run's active HUMAN wait (409 when the run is not waiting on a form, 422 on node mismatch, 403 when the wait is assigned to someone else). The submitted `inputs` become the form node's output, available to later nodes as `<node_id>.<field>`.
      * @param podId
      * @param runId
-     * @returns string Successful Response
+     * @param requestBody
+     * @returns WorkflowRunResponse Successful Response
      * @throws ApiError
      */
-    static workflowRunVisualize(podId, runId) {
+    static workflowRunFormSubmit(podId, runId, requestBody) {
         return __request(OpenAPI, {
-            method: 'GET',
-            url: '/pods/{pod_id}/workflow-runs/{run_id}/visualize',
+            method: 'POST',
+            url: '/pods/{pod_id}/workflow-runs/{run_id}/form',
             path: {
                 'pod_id': podId,
                 'run_id': runId,
             },
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },
         });
     }
     /**
-     * List Workflow Runs
-     * List recent runs for a given workflow.
+     * Visualize Workflow Run
+     * Render an HTML view of a run overlaid on its workflow graph.
      * @param podId
-     * @param workflowName
-     * @param limit
-     * @param pageToken
-     * @returns WorkflowRunListResponse Successful Response
+     * @param runId
+     * @returns string Successful Response
      * @throws ApiError
      */
-    static workflowRunList(podId, workflowName, limit = 100, pageToken) {
+    static workflowRunVisualize(podId, runId) {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/pods/{pod_id}/workflow-runs/{workflow_name}/runs',
+            url: '/pods/{pod_id}/workflow-runs/{run_id}/visualize',
             path: {
                 'pod_id': podId,
-                'workflow_name': workflowName,
-            },
-            query: {
-                'limit': limit,
-                'page_token': pageToken,
+                'run_id': runId,
             },
             errors: {
                 422: `Validation Error`,
@@ -146,7 +140,7 @@ export class WorkflowsService {
     }
     /**
      * Create Workflow
-     * Create a workflow definition. Use this before uploading graph nodes/edges with `workflow.graph.update`.
+     * Create a workflow definition. The graph (`nodes`/`edges`) can be included in this call to create a ready-to-run workflow in one step, or omitted to create a shell and upload the graph later with `workflow.graph.update`.
      * @param podId
      * @param requestBody
      * @returns FlowDetailResponse Successful Response
@@ -257,24 +251,48 @@ export class WorkflowsService {
         });
     }
     /**
-     * Start Workflow
-     * Start a new workflow run. For event/scheduled/datastore starts, the request body is treated as initial trigger payload and merged into execution context.
+     * List Workflow Runs
+     * List recent runs for a given workflow.
      * @param podId
      * @param workflowName
-     * @param requestBody
-     * @returns FlowRunEntity Successful Response
+     * @param limit
+     * @param pageToken
+     * @returns WorkflowRunListResponse Successful Response
+     * @throws ApiError
+     */
+    static workflowRunList(podId, workflowName, limit = 100, pageToken) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/pods/{pod_id}/workflows/{workflow_name}/runs',
+            path: {
+                'pod_id': podId,
+                'workflow_name': workflowName,
+            },
+            query: {
+                'limit': limit,
+                'page_token': pageToken,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
+    /**
+     * Create Workflow Run
+     * Create a new run for this workflow. Takes no request body: if the workflow's entry node is a FORM node the run is created WAITING on it (see `active_wait` in the response) and input is submitted via `workflow.run.form.submit`; otherwise the run executes immediately. Trigger payloads for scheduled/event/datastore starts are supplied by the platform, not through this endpoint.
+     * @param podId
+     * @param workflowName
+     * @returns WorkflowRunResponse Successful Response
      * @throws ApiError
      */
-    static workflowStart(podId, workflowName, requestBody) {
+    static workflowRunCreate(podId, workflowName) {
         return __request(OpenAPI, {
             method: 'POST',
-            url: '/pods/{pod_id}/workflows/{workflow_name}/start',
+            url: '/pods/{pod_id}/workflows/{workflow_name}/runs',
             path: {
                 'pod_id': podId,
                 'workflow_name': workflowName,
             },
-            body: requestBody,
-            mediaType: 'application/json',
             errors: {
                 422: `Validation Error`,
             },

package/dist/react/useAddPodMember.js

@@ -20,7 +20,7 @@ export function useAddPodMember({ client, podId, enabled = true, defaultRole = P
             const resolvedPodId = resolvePodId(client, podId);
             const nextMember = await client.podMembers.add(resolvedPodId, {
                 organization_member_id: organizationMemberId,
-                role: input.role ?? defaultRole,
+                roles: [input.role ?? defaultRole],
             });
             setAddedMember(nextMember);
             onSuccessRef.current?.(nextMember);

package/dist/react/useAssistantController.d.ts

@@ -80,6 +80,7 @@ export interface UseAssistantControllerOptions extends AssistantConversationScop
 export interface SendAssistantControllerMessageOptions {
     forceNewConversation?: boolean;
     metadata?: Record<string, unknown> | null;
+    conversationMetadata?: Record<string, unknown> | null;
     instructions?: string | null;
 }
 export type AssistantUserApprovalDecision = "APPROVE_ONCE" | "APPROVE_FOR_SESSION" | "DENY";

package/dist/react/useAssistantController.js

@@ -1075,6 +1075,7 @@ export function useAssistantController({ client, podId, agentName, assistantName
         const createdConversation = await sessionCreateConversation({
             title: titleSeed.slice(0, 120),
             instructions: typeof options.instructions === "undefined" ? instructions : options.instructions,
+            metadata: options.metadata ?? undefined,
             model: conversationModel,
             agentRuntime: conversationRuntime,
             ...scope,
@@ -1136,7 +1137,10 @@ export function useAssistantController({ client, podId, agentName, assistantName
         let conversationId = forceNewConversation ? null : activeConversationId;
         try {
             if (!conversationId) {
-                conversationId = await ensureConversation(trimmed, { instructions: options.instructions });
+                conversationId = await ensureConversation(trimmed, {
+                    instructions: options.instructions,
+                    metadata: options.conversationMetadata,
+                });
             }
             if (!conversationId) {
                 throw new Error("Conversation could not be initialized");

package/dist/react/useAssistantSession.d.ts

@@ -40,6 +40,7 @@ export interface UseAssistantSessionOptions {
 export interface CreateConversationInput {
     title?: string | null;
     instructions?: string | null;
+    metadata?: Record<string, unknown> | null;
     model?: ConversationModel | null;
     agentRuntime?: AgentRuntimeConfig | null;
     podId?: string | null;

package/dist/react/useAssistantSession.js

@@ -143,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;
@@ -274,6 +277,7 @@ export function useAssistantSession(options) {
                 instructions: typeof input.instructions === "undefined"
                     ? defaultInstructions ?? undefined
                     : input.instructions,
+                metadata: input.metadata ?? undefined,
                 pod_id: input.podId ?? defaultPodId ?? scopedClient.podId ?? undefined,
                 agent_name: input.agentName
                     ?? input.assistantName
@@ -391,6 +395,16 @@ 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) {
                     if (parsed.tokenKind === "tool") {
                         streamingToolTokenRef.current += parsed.token;
@@ -435,6 +449,28 @@ export function useAssistantSession(options) {
             }
             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();
@@ -464,12 +500,17 @@ 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) {

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/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) {