lemma-sdk 0.2.37 → 0.2.40

package/dist/openapi_client/services/WorkflowsService.js

@@ -1,6 +1,31 @@
 import { OpenAPI } from '../core/OpenAPI.js';
 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.
+     * @param podId
+     * @param limit
+     * @param pageToken
+     * @returns WorkflowRunWaitAssignmentListResponse Successful Response
+     * @throws ApiError
+     */
+    static workflowRunWaitingAssignedToMe(podId, limit = 100, pageToken) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/pods/{pod_id}/workflow-runs/waiting/assigned-to-me',
+            path: {
+                'pod_id': podId,
+            },
+            query: {
+                'limit': limit,
+                'page_token': pageToken,
+            },
+            errors: {
+                422: `Validation Error`,
+            },
+        });
+    }
     /**
      * Get Workflow Run
      * Get current state, context, and step history of a workflow run.
@@ -185,7 +210,7 @@ export class WorkflowsService {
     }
     /**
      * Update Workflow Metadata
-     * Update workflow-level metadata such as description/install mode. Workflow names are immutable after creation. Use `workflow.graph.update` for nodes and edges.
+     * Update workflow-level metadata such as description and schedule mode. Workflow names are immutable after creation. Use `workflow.graph.update` for nodes and edges.
      * @param podId
      * @param workflowName
      * @param requestBody
@@ -231,74 +256,6 @@ export class WorkflowsService {
             },
         });
     }
-    /**
-     * Install Workflow
-     * Install a workflow for runtime execution. Provide `account_id` when the workflow needs an integration account binding, and provide `schedule` when installing a scheduled workflow.
-     * @param podId
-     * @param workflowName
-     * @param requestBody
-     * @returns FlowInstallResponse Successful Response
-     * @throws ApiError
-     */
-    static workflowInstallCreate(podId, workflowName, requestBody) {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/pods/{pod_id}/workflows/{workflow_name}/install',
-            path: {
-                'pod_id': podId,
-                'workflow_name': workflowName,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-            errors: {
-                422: `Validation Error`,
-            },
-        });
-    }
-    /**
-     * List Workflow Installs
-     * List workflow installations visible to the current user. `GLOBAL` workflows return the pod-level install; `USER` workflows return the current user's install.
-     * @param podId
-     * @param workflowName
-     * @returns WorkflowInstallListResponse Successful Response
-     * @throws ApiError
-     */
-    static workflowInstallList(podId, workflowName) {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/pods/{pod_id}/workflows/{workflow_name}/installs',
-            path: {
-                'pod_id': podId,
-                'workflow_name': workflowName,
-            },
-            errors: {
-                422: `Validation Error`,
-            },
-        });
-    }
-    /**
-     * Uninstall Workflow
-     * Remove a previously created workflow installation binding.
-     * @param podId
-     * @param workflowName
-     * @param installId
-     * @returns void
-     * @throws ApiError
-     */
-    static workflowInstallDelete(podId, workflowName, installId) {
-        return __request(OpenAPI, {
-            method: 'DELETE',
-            url: '/pods/{pod_id}/workflows/{workflow_name}/installs/{install_id}',
-            path: {
-                'pod_id': podId,
-                'workflow_name': workflowName,
-                'install_id': installId,
-            },
-            errors: {
-                422: `Validation Error`,
-            },
-        });
-    }
     /**
      * 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.

package/dist/react/AuthGuard.js

@@ -98,7 +98,7 @@ export function AuthGuard({ client, children, loadingFallback = null, unauthenti
         setMembershipError(null);
         try {
             const currentUser = await client.users.current();
-            await client.podMembers.get(client.podId, currentUser.id);
+            await client.podMembers.lookupByUserId(client.podId, currentUser.id);
             setMembershipState("member");
             setJoinRequest(null);
             return;

package/dist/react/index.d.ts

@@ -2,18 +2,12 @@ export { AuthGuard } from "./AuthGuard.js";
 export type { AuthGuardProps } from "./AuthGuard.js";
 export { useAuth } from "./useAuth.js";
 export type { UseAuthResult } from "./useAuth.js";
-export { useAssistantRun } from "./useAssistantRun.js";
-export type { UseAssistantRunOptions, UseAssistantRunResult } from "./useAssistantRun.js";
 export { useConversations } from "./useConversations.js";
 export type { UseConversationsOptions, UseConversationsResult } from "./useConversations.js";
 export { useConversation } from "./useConversation.js";
 export type { UseConversationOptions, UseConversationResult } from "./useConversation.js";
 export { useConversationMessages } from "./useConversationMessages.js";
 export type { UseConversationMessagesOptions, UseConversationMessagesResult, } from "./useConversationMessages.js";
-export { useAgentRun } from "./useAgentRun.js";
-export type { UseAgentRunOptions, UseAgentRunResult } from "./useAgentRun.js";
-export { useAgentRuns } from "./useAgentRuns.js";
-export type { UseAgentRunsOptions, UseAgentRunsResult } from "./useAgentRuns.js";
 export { useAgentInputSchema } from "./useAgentInputSchema.js";
 export type { UseAgentInputSchemaOptions, UseAgentInputSchemaResult, } from "./useAgentInputSchema.js";
 export { useAssistantSession } from "./useAssistantSession.js";
@@ -92,14 +86,20 @@ export { useSchemaForm } from "./useSchemaForm.js";
 export type { UseSchemaFormOptions, UseSchemaFormResult } from "./useSchemaForm.js";
 export { useAssistantController } from "./useAssistantController.js";
 export type { AssistantAction, AssistantConversationScope, AssistantMessagePart, AssistantRenderableMessage, AssistantToolInvocation, UseAssistantControllerOptions, UseAssistantControllerResult, } from "./useAssistantController.js";
-export { useTaskSession } from "./useTaskSession.js";
-export type { CreateTaskInput, UseTaskSessionOptions, UseTaskSessionResult, } from "./useTaskSession.js";
 export { useFunctionSession } from "./useFunctionSession.js";
 export type { UseFunctionSessionOptions, UseFunctionSessionResult, } from "./useFunctionSession.js";
 export { useFunctionRun } from "./useFunctionRun.js";
 export type { UseFunctionRunOptions, UseFunctionRunResult } from "./useFunctionRun.js";
 export { useFunctionRuns } from "./useFunctionRuns.js";
 export type { UseFunctionRunsOptions, UseFunctionRunsResult } from "./useFunctionRuns.js";
+export { useSchedules } from "./useSchedules.js";
+export type { UseSchedulesOptions, UseSchedulesResult } from "./useSchedules.js";
+export { useCreateSchedule } from "./useCreateSchedule.js";
+export type { UseCreateScheduleOptions, UseCreateScheduleResult } from "./useCreateSchedule.js";
+export { useUpdateSchedule } from "./useUpdateSchedule.js";
+export type { UseUpdateScheduleOptions, UseUpdateScheduleResult } from "./useUpdateSchedule.js";
+export { useDeleteSchedule } from "./useDeleteSchedule.js";
+export type { UseDeleteScheduleOptions, UseDeleteScheduleResult } from "./useDeleteSchedule.js";
 export { useFlowSession } from "./useFlowSession.js";
 export type { UseFlowSessionOptions, UseFlowSessionResult, } from "./useFlowSession.js";
 export { useWorkflowStart } from "./useWorkflowStart.js";
@@ -108,6 +108,8 @@ export { useWorkflowRun } from "./useWorkflowRun.js";
 export type { UseWorkflowRunOptions, UseWorkflowRunResult } from "./useWorkflowRun.js";
 export { useWorkflowRuns } from "./useWorkflowRuns.js";
 export type { UseWorkflowRunsOptions, UseWorkflowRunsResult } from "./useWorkflowRuns.js";
+export { useWorkflowRunWaitAssignments } from "./useWorkflowRunWaitAssignments.js";
+export type { UseWorkflowRunWaitAssignmentsOptions, UseWorkflowRunWaitAssignmentsResult, } from "./useWorkflowRunWaitAssignments.js";
 export { useWorkflowResume } from "./useWorkflowResume.js";
 export type { UseWorkflowResumeOptions, UseWorkflowResumeResult, } from "./useWorkflowResume.js";
 export { useFlowRunHistory } from "./useFlowRunHistory.js";

package/dist/react/index.js

@@ -1,11 +1,8 @@
 export { AuthGuard } from "./AuthGuard.js";
 export { useAuth } from "./useAuth.js";
-export { useAssistantRun } from "./useAssistantRun.js";
 export { useConversations } from "./useConversations.js";
 export { useConversation } from "./useConversation.js";
 export { useConversationMessages } from "./useConversationMessages.js";
-export { useAgentRun } from "./useAgentRun.js";
-export { useAgentRuns } from "./useAgentRuns.js";
 export { useAgentInputSchema } from "./useAgentInputSchema.js";
 export { useAssistantSession } from "./useAssistantSession.js";
 export { useAssistantRuntime } from "./useAssistantRuntime.js";
@@ -45,13 +42,17 @@ export { useRecordSchema } from "./useRecordSchema.js";
 export { useRecordForm } from "./useRecordForm.js";
 export { useSchemaForm } from "./useSchemaForm.js";
 export { useAssistantController } from "./useAssistantController.js";
-export { useTaskSession } from "./useTaskSession.js";
 export { useFunctionSession } from "./useFunctionSession.js";
 export { useFunctionRun } from "./useFunctionRun.js";
 export { useFunctionRuns } from "./useFunctionRuns.js";
+export { useSchedules } from "./useSchedules.js";
+export { useCreateSchedule } from "./useCreateSchedule.js";
+export { useUpdateSchedule } from "./useUpdateSchedule.js";
+export { useDeleteSchedule } from "./useDeleteSchedule.js";
 export { useFlowSession } from "./useFlowSession.js";
 export { useWorkflowStart } from "./useWorkflowStart.js";
 export { useWorkflowRun } from "./useWorkflowRun.js";
 export { useWorkflowRuns } from "./useWorkflowRuns.js";
+export { useWorkflowRunWaitAssignments } from "./useWorkflowRunWaitAssignments.js";
 export { useWorkflowResume } from "./useWorkflowResume.js";
 export { useFlowRunHistory } from "./useFlowRunHistory.js";

package/dist/react/useAssistantController.js

@@ -1057,7 +1057,6 @@ export function useAssistantController({ client, podId, agentName, assistantName
             touchConversation(finalConversationId, { status: "running" });
             await sessionSendMessage(messageContent, {
                 conversationId: finalConversationId,
-                createIfMissing: false,
             });
             touchConversation(finalConversationId, { updated_at: new Date().toISOString() });
         }
@@ -1102,7 +1101,6 @@ export function useAssistantController({ client, podId, agentName, assistantName
             setIsStreaming(true);
             await sessionSendMessage(fileMessage, {
                 conversationId: activeId,
-                createIfMissing: false,
             });
             await loadConversationMessages(activeId);
             touchConversation(activeId, { updated_at: new Date().toISOString() });

package/dist/react/useAssistantSession.d.ts

@@ -54,8 +54,6 @@ export interface CreateConversationInput {
 }
 export interface SendAssistantMessageOptions {
     conversationId?: string | null;
-    createIfMissing?: boolean;
-    createConversation?: CreateConversationInput;
     syncOnTurnEnd?: boolean;
 }
 export interface ResumeAssistantOptions {

package/dist/react/useAssistantSession.js

@@ -342,7 +342,7 @@ export function useAssistantSession(options) {
         }
         catch (streamError) {
             if (!(streamError instanceof Error && streamError.name === "AbortError")) {
-                const normalized = normalizeError(streamError, "Failed to stream agent run.");
+                const normalized = normalizeError(streamError, "Failed to stream conversation.");
                 setError(normalized);
                 onErrorRef.current?.(streamError);
             }
@@ -362,7 +362,7 @@ export function useAssistantSession(options) {
         setConversationStatus,
         syncOnTurnEnd,
     ]);
-    const ensureConversation = useCallback(async (overrideConversationId, options) => {
+    const ensureConversation = useCallback(async (overrideConversationId) => {
         const existingId = overrideConversationId ?? conversationId;
         if (existingId) {
             // Avoid a network roundtrip on every send when we already have this conversation in state.
@@ -374,23 +374,17 @@ export function useAssistantSession(options) {
                 return existing;
             throw new Error("Failed to resolve existing conversation.");
         }
-        if (options?.createIfMissing !== true) {
-            throw new Error("conversationId is required.");
-        }
-        return createConversation({
-            ...(options.createConversation ?? {}),
-            setActive: true,
-        });
-    }, [conversation, conversationId, createConversation, refreshConversation]);
+        throw new Error("conversationId is required. Create a conversation before sending a message.");
+    }, [conversation, conversationId, refreshConversation]);
     const sendMessage = useCallback(async (content, input = {}) => {
         setError(null);
         try {
-            const resolvedConversation = await ensureConversation(input.conversationId, input);
+            const resolvedConversation = await ensureConversation(input.conversationId);
             const resolvedConversationId = requireConversationId(resolvedConversation.id);
             cancel();
             const controller = new AbortController();
             abortRef.current = controller;
-            const scope = normalizeScope(client, defaultScope, input.createConversation);
+            const scope = normalizeScope(client, defaultScope);
             const scopedClient = applyPodScope(client, scope.podId);
             const stream = await scopedClient.conversations.sendMessageStream(resolvedConversationId, { content }, {
                 pod_id: scope.podId ?? undefined,
@@ -438,7 +432,7 @@ export function useAssistantSession(options) {
             });
         }
         catch (resumeError) {
-            const normalized = normalizeError(resumeError, "Failed to resume agent run.");
+            const normalized = normalizeError(resumeError, "Failed to resume conversation.");
             setError(normalized);
             onErrorRef.current?.(resumeError);
             throw normalized;
@@ -491,7 +485,7 @@ export function useAssistantSession(options) {
             clearStreamingText();
         }
         catch (stopError) {
-            const normalized = normalizeError(stopError, "Failed to stop agent run.");
+            const normalized = normalizeError(stopError, "Failed to stop conversation.");
             setError(normalized);
             onErrorRef.current?.(stopError);
             throw normalized;

package/dist/react/useCreateSchedule.d.ts

@@ -0,0 +1,17 @@
+import type { LemmaClient } from "../client.js";
+import type { CreateScheduleRequest, Schedule } from "../types.js";
+export interface UseCreateScheduleOptions {
+    client: LemmaClient;
+    podId?: string;
+    enabled?: boolean;
+    onSuccess?: (schedule: Schedule) => void;
+    onError?: (error: unknown) => void;
+}
+export interface UseCreateScheduleResult {
+    schedule: Schedule | null;
+    isSubmitting: boolean;
+    error: Error | null;
+    create: (payload: CreateScheduleRequest) => Promise<Schedule | null>;
+    reset: () => void;
+}
+export declare function useCreateSchedule({ client, podId, enabled, onSuccess, onError, }: UseCreateScheduleOptions): UseCreateScheduleResult;

package/dist/react/useCreateSchedule.js

@@ -0,0 +1,45 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
+export function useCreateSchedule({ client, podId, enabled = true, onSuccess, onError, }) {
+    const [schedule, setSchedule] = useState(null);
+    const [isSubmitting, setIsSubmitting] = useState(false);
+    const [error, setError] = useState(null);
+    const onSuccessRef = useRef(onSuccess);
+    const onErrorRef = useRef(onError);
+    useEffect(() => { onSuccessRef.current = onSuccess; }, [onSuccess]);
+    useEffect(() => { onErrorRef.current = onError; }, [onError]);
+    const create = useCallback(async (payload) => {
+        if (!enabled)
+            return null;
+        setIsSubmitting(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const nextSchedule = await scopedClient.schedules.create(payload);
+            setSchedule(nextSchedule);
+            onSuccessRef.current?.(nextSchedule);
+            return nextSchedule;
+        }
+        catch (mutationError) {
+            const normalized = normalizeError(mutationError, "Failed to create schedule.");
+            setError(normalized);
+            onErrorRef.current?.(mutationError);
+            return null;
+        }
+        finally {
+            setIsSubmitting(false);
+        }
+    }, [client, enabled, podId]);
+    const reset = useCallback(() => {
+        setSchedule(null);
+        setError(null);
+        setIsSubmitting(false);
+    }, []);
+    return useMemo(() => ({
+        schedule,
+        isSubmitting,
+        error,
+        create,
+        reset,
+    }), [create, error, isSubmitting, reset, schedule]);
+}

package/dist/react/useDeleteSchedule.d.ts

@@ -0,0 +1,19 @@
+import type { LemmaClient } from "../client.js";
+export interface UseDeleteScheduleOptions {
+    client: LemmaClient;
+    podId?: string;
+    scheduleId?: string | null;
+    enabled?: boolean;
+    onSuccess?: (scheduleId: string) => void;
+    onError?: (error: unknown) => void;
+}
+export interface UseDeleteScheduleResult {
+    deletedScheduleId: string | null;
+    isSubmitting: boolean;
+    error: Error | null;
+    remove: (overrides?: {
+        scheduleId?: string | null;
+    }) => Promise<boolean>;
+    reset: () => void;
+}
+export declare function useDeleteSchedule({ client, podId, scheduleId, enabled, onSuccess, onError, }: UseDeleteScheduleOptions): UseDeleteScheduleResult;

package/dist/react/useDeleteSchedule.js

@@ -0,0 +1,49 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
+export function useDeleteSchedule({ client, podId, scheduleId = null, enabled = true, onSuccess, onError, }) {
+    const [deletedScheduleId, setDeletedScheduleId] = useState(null);
+    const [isSubmitting, setIsSubmitting] = useState(false);
+    const [error, setError] = useState(null);
+    const onSuccessRef = useRef(onSuccess);
+    const onErrorRef = useRef(onError);
+    useEffect(() => { onSuccessRef.current = onSuccess; }, [onSuccess]);
+    useEffect(() => { onErrorRef.current = onError; }, [onError]);
+    const trimmedScheduleId = typeof scheduleId === "string" ? scheduleId.trim() : "";
+    const remove = useCallback(async (overrides = {}) => {
+        const nextScheduleId = typeof overrides.scheduleId === "string"
+            ? overrides.scheduleId.trim()
+            : trimmedScheduleId;
+        if (!enabled || nextScheduleId.length === 0)
+            return false;
+        setIsSubmitting(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            await scopedClient.schedules.delete(nextScheduleId);
+            setDeletedScheduleId(nextScheduleId);
+            onSuccessRef.current?.(nextScheduleId);
+            return true;
+        }
+        catch (mutationError) {
+            const normalized = normalizeError(mutationError, "Failed to delete schedule.");
+            setError(normalized);
+            onErrorRef.current?.(mutationError);
+            return false;
+        }
+        finally {
+            setIsSubmitting(false);
+        }
+    }, [client, enabled, podId, trimmedScheduleId]);
+    const reset = useCallback(() => {
+        setDeletedScheduleId(null);
+        setError(null);
+        setIsSubmitting(false);
+    }, []);
+    return useMemo(() => ({
+        deletedScheduleId,
+        isSubmitting,
+        error,
+        remove,
+        reset,
+    }), [deletedScheduleId, error, isSubmitting, remove, reset]);
+}

package/dist/react/usePodAccess.js

@@ -30,7 +30,7 @@ export function usePodAccess({ client, podId, enabled = true, autoLoad = true, }
             const currentUser = await client.users.current();
             setUser(currentUser);
             try {
-                const nextMember = await client.podMembers.get(resolvedPodId, currentUser.id);
+                const nextMember = await client.podMembers.lookupByUserId(resolvedPodId, currentUser.id);
                 setMember(nextMember);
                 setJoinRequest(null);
                 setStatus("member");

package/dist/react/useSchedules.d.ts

@@ -0,0 +1,30 @@
+import type { LemmaClient } from "../client.js";
+import type { Schedule, ScheduleType } from "../types.js";
+export interface UseSchedulesOptions {
+    client: LemmaClient;
+    podId?: string;
+    enabled?: boolean;
+    autoLoad?: boolean;
+    scheduleType?: ScheduleType | null;
+    isActive?: boolean | null;
+    agentName?: string | null;
+    workflowName?: string | null;
+    limit?: number;
+    pageToken?: string | null;
+}
+export interface UseSchedulesResult {
+    schedules: Schedule[];
+    total: number;
+    nextPageToken: string | null;
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    error: Error | null;
+    refresh: (overrides?: {
+        limit?: number;
+        pageToken?: string | null;
+    }) => Promise<Schedule[]>;
+    loadMore: (overrides?: {
+        limit?: number;
+    }) => Promise<Schedule[]>;
+}
+export declare function useSchedules({ client, podId, enabled, autoLoad, scheduleType, isActive, agentName, workflowName, limit, pageToken, }: UseSchedulesOptions): UseSchedulesResult;

package/dist/react/useSchedules.js

@@ -0,0 +1,123 @@
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
+export function useSchedules({ client, podId, enabled = true, autoLoad = true, scheduleType = null, isActive = null, agentName = null, workflowName = null, limit = 100, pageToken = null, }) {
+    const [schedules, setSchedules] = useState([]);
+    const [total, setTotal] = useState(0);
+    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) {
+            setSchedules([]);
+            setTotal(0);
+            setNextPageToken(null);
+            setError(null);
+            setIsLoading(false);
+            return [];
+        }
+        setIsLoading(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const response = await scopedClient.schedules.list({
+                scheduleType,
+                isActive,
+                agentName,
+                workflowName,
+                limit: overrides.limit ?? limit,
+                pageToken: overrides.pageToken ?? pageToken,
+            });
+            if (signal?.aborted)
+                return [];
+            const nextSchedules = response.items ?? [];
+            setSchedules(nextSchedules);
+            setTotal(response.total ?? nextSchedules.length);
+            setNextPageToken(response.next_page_token ?? null);
+            return nextSchedules;
+        }
+        catch (refreshError) {
+            if (signal?.aborted)
+                return [];
+            const normalized = normalizeError(refreshError, "Failed to load schedules.");
+            setError(normalized);
+            return [];
+        }
+        finally {
+            if (!signal?.aborted)
+                setIsLoading(false);
+        }
+    }, [agentName, client, enabled, isActive, limit, pageToken, podId, scheduleType, workflowName]);
+    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.schedules.list({
+                scheduleType,
+                isActive,
+                agentName,
+                workflowName,
+                limit: overrides.limit ?? limit,
+                pageToken: nextPageToken,
+            });
+            const moreSchedules = response.items ?? [];
+            setSchedules((previous) => [...previous, ...moreSchedules]);
+            setTotal(response.total ?? schedules.length + moreSchedules.length);
+            setNextPageToken(response.next_page_token ?? null);
+            return moreSchedules;
+        }
+        catch (loadError) {
+            const normalized = normalizeError(loadError, "Failed to load more schedules.");
+            setError(normalized);
+            return [];
+        }
+        finally {
+            setIsLoadingMore(false);
+        }
+    }, [
+        agentName,
+        client,
+        enabled,
+        isActive,
+        isLoading,
+        isLoadingMore,
+        limit,
+        nextPageToken,
+        podId,
+        scheduleType,
+        schedules.length,
+        workflowName,
+    ]);
+    useEffect(() => {
+        if (!enabled) {
+            setSchedules([]);
+            setTotal(0);
+            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(() => ({
+        schedules,
+        total,
+        nextPageToken,
+        isLoading,
+        isLoadingMore,
+        error,
+        refresh,
+        loadMore,
+    }), [error, isLoading, isLoadingMore, loadMore, nextPageToken, refresh, schedules, total]);
+}

package/dist/react/useUpdateSchedule.d.ts

@@ -0,0 +1,20 @@
+import type { LemmaClient } from "../client.js";
+import type { Schedule, UpdateScheduleRequest } from "../types.js";
+export interface UseUpdateScheduleOptions {
+    client: LemmaClient;
+    podId?: string;
+    scheduleId?: string | null;
+    enabled?: boolean;
+    onSuccess?: (schedule: Schedule) => void;
+    onError?: (error: unknown) => void;
+}
+export interface UseUpdateScheduleResult {
+    schedule: Schedule | null;
+    isSubmitting: boolean;
+    error: Error | null;
+    update: (payload: UpdateScheduleRequest, overrides?: {
+        scheduleId?: string | null;
+    }) => Promise<Schedule | null>;
+    reset: () => void;
+}
+export declare function useUpdateSchedule({ client, podId, scheduleId, enabled, onSuccess, onError, }: UseUpdateScheduleOptions): UseUpdateScheduleResult;

package/dist/react/useUpdateSchedule.js

@@ -0,0 +1,49 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { normalizeError, resolvePodClient } from "./utils.js";
+export function useUpdateSchedule({ client, podId, scheduleId = null, enabled = true, onSuccess, onError, }) {
+    const [schedule, setSchedule] = useState(null);
+    const [isSubmitting, setIsSubmitting] = useState(false);
+    const [error, setError] = useState(null);
+    const onSuccessRef = useRef(onSuccess);
+    const onErrorRef = useRef(onError);
+    useEffect(() => { onSuccessRef.current = onSuccess; }, [onSuccess]);
+    useEffect(() => { onErrorRef.current = onError; }, [onError]);
+    const trimmedScheduleId = typeof scheduleId === "string" ? scheduleId.trim() : "";
+    const update = useCallback(async (payload, overrides = {}) => {
+        const nextScheduleId = typeof overrides.scheduleId === "string"
+            ? overrides.scheduleId.trim()
+            : trimmedScheduleId;
+        if (!enabled || nextScheduleId.length === 0)
+            return null;
+        setIsSubmitting(true);
+        setError(null);
+        try {
+            const scopedClient = resolvePodClient(client, podId);
+            const nextSchedule = await scopedClient.schedules.update(nextScheduleId, payload);
+            setSchedule(nextSchedule);
+            onSuccessRef.current?.(nextSchedule);
+            return nextSchedule;
+        }
+        catch (mutationError) {
+            const normalized = normalizeError(mutationError, "Failed to update schedule.");
+            setError(normalized);
+            onErrorRef.current?.(mutationError);
+            return null;
+        }
+        finally {
+            setIsSubmitting(false);
+        }
+    }, [client, enabled, podId, trimmedScheduleId]);
+    const reset = useCallback(() => {
+        setSchedule(null);
+        setError(null);
+        setIsSubmitting(false);
+    }, []);
+    return useMemo(() => ({
+        schedule,
+        isSubmitting,
+        error,
+        update,
+        reset,
+    }), [error, isSubmitting, reset, schedule, update]);
+}