@elevasis/ui 1.3.0 → 1.3.2

package/dist/hooks/published.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"published.d.ts","sourceRoot":"","sources":["../../src/hooks/published.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,cAAc,cAAc,CAAA;AAG5B,cAAc,cAAc,CAAA;AAG5B,cAAc,cAAc,CAAA;AAG5B,cAAc,iBAAiB,CAAA;AAG/B,cAAc,iBAAiB,CAAA;AAG/B,cAAc,YAAY,CAAA;AAG1B,cAAc,SAAS,CAAA;AAGvB,cAAc,kBAAkB,CAAA;AAGhC,cAAc,OAAO,CAAA;AAGrB,cAAc,YAAY,CAAA"}

package/dist/hooks/published.js

@@ -1,5 +1,371 @@
-export { OperationsService, executionsKeys, observabilityKeys, scheduleKeys, useActivities, useActivityTrend, useBulkDeleteExecutions, useBusinessImpact, useCancelExecution, useCancelSchedule, useCostBreakdown, useCostByModel, useCostSummary, useCostTrends, useCreateSchedule, useDashboardMetrics, useDeleteExecution, useDeleteSchedule, useErrorAnalysis, useErrorDetail, useErrorDetails, useErrorDistribution, useErrorTrends, useExecuteAsync, useExecution, useExecutionHealth, useExecutionLogs, useExecutions, useGetExecutionHistory, useGetSchedule, useListSchedules, usePauseSchedule, useResolveAllErrors, useResolveError, useResolveErrorsByExecution, useResourceDefinition, useResources, useResumeSchedule, useRetryExecution, useTopFailingResources, useUnresolveError, useUpdateAnchor, useUpdateSchedule } from '../chunk-BZTA7IIL.js';
-export { useMarkAllAsRead, useMarkAsRead, useNotificationCount, useNotifications } from '../chunk-BLO4SISK.js';
+import { OperationsService, SessionIdParamSchema, ExecutionIdParamsSchema, WebSocketSessionTurnSchema } from '../chunk-6IX5JZEH.js';
+export { OperationsService, createUseFeatureAccess, executionsKeys, observabilityKeys, scheduleKeys, sortData, useActivities, useActivityTrend, useBatchDelete, useBulkDeleteExecutions, useBusinessImpact, useCancelExecution, useCancelSchedule, useCostBreakdown, useCostByModel, useCostSummary, useCostTrends, useCreateSchedule, useDashboardMetrics, useDeleteExecution, useDeleteSchedule, useErrorAnalysis, useErrorDetail, useErrorDetails, useErrorDistribution, useErrorNotification, useErrorTrends, useExecuteAsync, useExecution, useExecutionHealth, useExecutionLogs, useExecutions, useGetExecutionHistory, useGetSchedule, useListSchedules, useMarkAllAsRead, useMarkAsRead, useNotificationCount, useNotifications, usePaginationState, usePauseSchedule, useResolveAllErrors, useResolveError, useResolveErrorsByExecution, useResourceDefinition, useResources, useResumeSchedule, useRetryExecution, useSSEConnection, useSortedData, useSuccessNotification, useTableSelection, useTableSort, useTopFailingResources, useUnresolveError, useUpdateAnchor, useUpdateSchedule, useWarningNotification } from '../chunk-6IX5JZEH.js';
+import '../chunk-JGJSZ3UE.js';
 import '../chunk-TIRMFDM4.js';
 import '../chunk-4VGWQ5AN.js';
-import '../chunk-KA7LO7U5.js';
+import '../chunk-FWZJH3TL.js';
+import { useElevasisServices } from '../chunk-KA7LO7U5.js';
+import { useOrganization } from '../chunk-DD3CCMCZ.js';
+import { useAuthContext } from '../chunk-7PLEQFHO.js';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+import { useState, useRef, useCallback, useEffect } from 'react';
+
+// src/hooks/sessions/queryKeys.ts
+var sessionsKeys = {
+  all: ["sessions"],
+  sessions: (org, params) => [...sessionsKeys.all, "list", org, params],
+  session: (org, sessionId) => [...sessionsKeys.all, "detail", org, sessionId],
+  executions: (org, sessionId) => [...sessionsKeys.all, org, sessionId, "executions"],
+  execution: (org, sessionId, executionId) => [...sessionsKeys.all, org, sessionId, "executions", executionId],
+  messages: (org, sessionId) => [...sessionsKeys.all, org, sessionId, "messages"]
+};
+
+// src/hooks/sessions/constants.ts
+var REFETCH_INTERVAL_RUNNING = 2e3;
+var WS_RECONNECT_BASE_DELAY = 1e3;
+var WS_RECONNECT_MAX_DELAY = 3e4;
+var WS_MAX_RETRIES_BEFORE_ERROR = 3;
+function useSessions(params, options) {
+  const { apiRequest, isReady } = useElevasisServices();
+  const { currentMembership } = useOrganization();
+  const organizationName = currentMembership?.organization?.name;
+  return useQuery({
+    queryKey: sessionsKeys.sessions(organizationName || "", params),
+    queryFn: async () => {
+      const service = new OperationsService(apiRequest);
+      return service.listSessions(params);
+    },
+    enabled: isReady && (options?.enabled ?? true)
+  });
+}
+function useSession(sessionId) {
+  const { apiRequest, isReady } = useElevasisServices();
+  const { currentMembership } = useOrganization();
+  const organizationName = currentMembership?.organization?.name;
+  return useQuery({
+    queryKey: sessionsKeys.session(organizationName || "", sessionId),
+    queryFn: () => {
+      const service = new OperationsService(apiRequest);
+      return service.getSession(sessionId);
+    },
+    enabled: isReady && !!sessionId
+  });
+}
+function useCreateSession() {
+  const { apiRequest } = useElevasisServices();
+  const { currentMembership } = useOrganization();
+  const organizationName = currentMembership?.organization?.name;
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (resourceId) => {
+      const service = new OperationsService(apiRequest);
+      return service.createSession(resourceId);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: sessionsKeys.sessions(organizationName || "") });
+    }
+  });
+}
+function useDeleteSession() {
+  const { apiRequest } = useElevasisServices();
+  const { currentMembership } = useOrganization();
+  const organizationName = currentMembership?.organization?.name;
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (sessionId) => {
+      SessionIdParamSchema.parse({ sessionId });
+      await apiRequest(`/sessions/${sessionId}`, {
+        method: "DELETE"
+      });
+    },
+    onSuccess: (_, sessionId) => {
+      queryClient.removeQueries({
+        queryKey: sessionsKeys.session(organizationName || "", sessionId)
+      });
+      queryClient.invalidateQueries({
+        queryKey: sessionsKeys.sessions(organizationName || "")
+      });
+    }
+  });
+}
+function useArchiveSession() {
+  const { apiRequest } = useElevasisServices();
+  const { currentMembership } = useOrganization();
+  const organizationName = currentMembership?.organization?.name;
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (sessionId) => {
+      const service = new OperationsService(apiRequest);
+      return service.archiveSession(sessionId);
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: sessionsKeys.sessions(organizationName || "") });
+    }
+  });
+}
+function useSessionExecutions(sessionId) {
+  const { apiRequest, isReady } = useElevasisServices();
+  const { currentSupabaseOrganizationId } = useOrganization();
+  return useQuery({
+    queryKey: sessionsKeys.executions(currentSupabaseOrganizationId || "", sessionId),
+    queryFn: async () => {
+      SessionIdParamSchema.parse({ sessionId });
+      return apiRequest(`/sessions/${sessionId}/executions`, {
+        method: "GET"
+      });
+    },
+    enabled: isReady && !!sessionId,
+    staleTime: 0
+  });
+}
+function useSessionExecution(sessionId, executionId) {
+  const { apiRequest, isReady } = useElevasisServices();
+  const { currentSupabaseOrganizationId } = useOrganization();
+  return useQuery({
+    queryKey: sessionsKeys.execution(currentSupabaseOrganizationId || "", sessionId, executionId),
+    queryFn: async () => {
+      ExecutionIdParamsSchema.parse({ sessionId, executionId });
+      return apiRequest(`/sessions/${sessionId}/executions/${executionId}`, {
+        method: "GET"
+      });
+    },
+    enabled: isReady && !!sessionId && !!executionId,
+    refetchInterval: (query) => {
+      const data = query.state.data;
+      const shouldRefetch = data?.status === "running";
+      return shouldRefetch ? REFETCH_INTERVAL_RUNNING : false;
+    }
+  });
+}
+function useSessionMessages(sessionId) {
+  const { apiRequest, isReady } = useElevasisServices();
+  const { currentSupabaseOrganizationId } = useOrganization();
+  return useQuery({
+    queryKey: sessionsKeys.messages(currentSupabaseOrganizationId || "", sessionId),
+    queryFn: async () => {
+      SessionIdParamSchema.parse({ sessionId });
+      const response = await apiRequest(`/sessions/${sessionId}/messages`, {
+        method: "GET"
+      });
+      const messages = response.messages.map((msg) => ({
+        ...msg,
+        createdAt: new Date(msg.createdAt)
+      }));
+      return messages;
+    },
+    enabled: isReady && !!sessionId,
+    staleTime: 0
+  });
+}
+function formatMessageEvent(event) {
+  switch (event.type) {
+    case "user_message":
+      return event.text;
+    case "assistant_message":
+      return event.text;
+    case "agent:started":
+      return "\u{1F916} Agent started reasoning";
+    case "agent:reasoning":
+      return `\u{1F4AD} Reasoning (Iteration ${event.iteration})`;
+    case "agent:tool_call":
+      return `\u{1F527} Tool: ${event.toolName}`;
+    case "agent:tool_result":
+      return event.success ? "\u2705 Tool Result" : "\u26A0\uFE0F Tool Result (Failed)";
+    case "agent:completed":
+      return "\u2705 Agent completed";
+    case "agent:error":
+      return `\u274C Agent error: ${event.error}`;
+  }
+}
+function getWsUrl(apiUrl) {
+  const url = new URL(apiUrl);
+  const protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  return `${protocol}//${url.host}`;
+}
+function useSessionWebSocket(sessionId, apiUrl) {
+  const [messages, setMessages] = useState([]);
+  const [state, setState] = useState({
+    isConnected: false,
+    isProcessing: false,
+    error: null
+  });
+  const [lastTokenUsage, setLastTokenUsage] = useState(null);
+  const wsRef = useRef(null);
+  const retryCountRef = useRef(0);
+  const reconnectTimeoutRef = useRef(null);
+  const { getAccessToken } = useAuthContext();
+  const { currentWorkOSOrganizationId, currentSupabaseOrganizationId } = useOrganization();
+  const queryClient = useQueryClient();
+  const getAccessTokenRef = useRef(getAccessToken);
+  getAccessTokenRef.current = getAccessToken;
+  const currentWorkOSOrgIdRef = useRef(currentWorkOSOrganizationId);
+  currentWorkOSOrgIdRef.current = currentWorkOSOrganizationId;
+  const queryClientRef = useRef(queryClient);
+  queryClientRef.current = queryClient;
+  const currentSupabaseOrgIdRef = useRef(currentSupabaseOrganizationId);
+  currentSupabaseOrgIdRef.current = currentSupabaseOrganizationId;
+  const connect = useCallback(async () => {
+    if (!currentWorkOSOrgIdRef.current) {
+      return;
+    }
+    if (wsRef.current?.readyState === WebSocket.OPEN || wsRef.current?.readyState === WebSocket.CONNECTING) {
+      return;
+    }
+    const token = await getAccessTokenRef.current();
+    if (!token) {
+      return;
+    }
+    const orgId = currentWorkOSOrgIdRef.current;
+    const wsUrl = `${getWsUrl(apiUrl)}/ws/sessions/${sessionId}?token=${token}&orgId=${orgId}`;
+    const ws = new WebSocket(wsUrl);
+    ws.onopen = () => {
+      setState((prev) => ({ ...prev, isConnected: true, error: null }));
+      retryCountRef.current = 0;
+      const supabaseOrgId = currentSupabaseOrgIdRef.current;
+      if (supabaseOrgId) {
+        queryClientRef.current.invalidateQueries({
+          queryKey: sessionsKeys.messages(supabaseOrgId, sessionId)
+        });
+      }
+    };
+    ws.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data.type && data.type !== "turn:complete" && data.type !== "error") {
+          const tempMessage = {
+            id: `temp-${Date.now()}`,
+            role: data.type === "user_message" ? "user" : "assistant",
+            messageType: data.type,
+            text: formatMessageEvent(data),
+            // Format based on type
+            metadata: data.type.startsWith("agent:") ? data : void 0,
+            turnNumber: 999999,
+            // High placeholder so temp messages sort to bottom
+            messageIndex: Date.now(),
+            // Use timestamp for unique ordering
+            createdAt: /* @__PURE__ */ new Date()
+          };
+          setMessages((prev) => [...prev, tempMessage]);
+        } else if (data.type === "turn:complete") {
+          if (data.tokenUsage) {
+            setLastTokenUsage(data.tokenUsage);
+          }
+          setState((prev) => ({ ...prev, isProcessing: false }));
+          const supabaseOrgId = currentSupabaseOrgIdRef.current;
+          if (supabaseOrgId) {
+            queryClientRef.current.invalidateQueries({
+              queryKey: sessionsKeys.messages(supabaseOrgId, sessionId)
+            });
+            queryClientRef.current.invalidateQueries({
+              queryKey: sessionsKeys.executions(supabaseOrgId, sessionId)
+            });
+            queryClientRef.current.invalidateQueries({
+              queryKey: sessionsKeys.session(supabaseOrgId, sessionId)
+            });
+          }
+        } else if (data.type === "error") {
+          setState((prev) => ({
+            ...prev,
+            error: data.error,
+            isProcessing: false
+          }));
+        }
+      } catch (error) {
+        console.error("Failed to parse WebSocket message:", error);
+      }
+    };
+    ws.onerror = () => {
+    };
+    ws.onclose = (event) => {
+      setState((prev) => ({ ...prev, isConnected: false }));
+      if (!event.wasClean && retryCountRef.current >= WS_MAX_RETRIES_BEFORE_ERROR) {
+        setState((prev) => ({
+          ...prev,
+          error: "Unable to connect to session. Retrying..."
+        }));
+      }
+      const terminalCodes = [1003, 1008];
+      if (terminalCodes.includes(event.code) || event.code >= 4e3) {
+        setState((prev) => ({
+          ...prev,
+          error: `Connection rejected (code ${event.code})`
+        }));
+        return;
+      }
+      const delay = Math.min(WS_RECONNECT_BASE_DELAY * Math.pow(2, retryCountRef.current), WS_RECONNECT_MAX_DELAY);
+      retryCountRef.current += 1;
+      reconnectTimeoutRef.current = setTimeout(() => {
+        connect();
+      }, delay);
+    };
+    wsRef.current = ws;
+  }, [sessionId, apiUrl]);
+  useEffect(() => {
+    retryCountRef.current = 0;
+    if (currentWorkOSOrgIdRef.current) {
+      connect();
+    }
+    return () => {
+      if (reconnectTimeoutRef.current) {
+        clearTimeout(reconnectTimeoutRef.current);
+      }
+      if (wsRef.current) {
+        wsRef.current.close();
+        wsRef.current = null;
+      }
+    };
+  }, [sessionId, currentWorkOSOrganizationId, connect]);
+  const sendMessage = useCallback(
+    (text, pageContext) => {
+      const trimmed = text.trim();
+      if (!trimmed) {
+        return;
+      }
+      if (!wsRef.current || state.isProcessing) {
+        return;
+      }
+      if (wsRef.current.readyState !== WebSocket.OPEN) {
+        setState((prev) => ({
+          ...prev,
+          error: "WebSocket not connected"
+        }));
+        return;
+      }
+      const userMessage = {
+        id: `temp-${Date.now()}`,
+        role: "user",
+        messageType: "user_message",
+        text: trimmed,
+        turnNumber: 999999,
+        // High placeholder so temp messages sort to bottom
+        messageIndex: Date.now(),
+        // Use timestamp for unique ordering
+        createdAt: /* @__PURE__ */ new Date()
+      };
+      setMessages((prev) => [...prev, userMessage]);
+      const input = { message: trimmed };
+      if (pageContext) {
+        input.pageContext = pageContext;
+      }
+      const message = WebSocketSessionTurnSchema.parse({
+        type: "session:turn",
+        input
+      });
+      wsRef.current.send(JSON.stringify(message));
+      setState((prev) => ({ ...prev, isProcessing: true, error: null }));
+    },
+    [state.isProcessing, sessionId]
+  );
+  const clearError = useCallback(() => {
+    setState((prev) => ({ ...prev, error: null }));
+  }, []);
+  return {
+    messages,
+    state,
+    sendMessage,
+    clearError,
+    lastTokenUsage
+  };
+}
+
+export { REFETCH_INTERVAL_RUNNING, WS_MAX_RETRIES_BEFORE_ERROR, WS_RECONNECT_BASE_DELAY, WS_RECONNECT_MAX_DELAY, sessionsKeys, useArchiveSession, useCreateSession, useDeleteSession, useSession, useSessionExecution, useSessionExecutions, useSessionMessages, useSessionWebSocket, useSessions };

package/dist/hooks/scheduling/index.d.ts

@@ -0,0 +1,5 @@
+export { scheduleKeys } from './queryKeys';
+export type { ListSchedulesFilters } from './queryKeys';
+export { useListSchedules, useGetSchedule, useGetExecutionHistory, useCreateSchedule, useUpdateSchedule, useUpdateAnchor, usePauseSchedule, useResumeSchedule, useCancelSchedule, useDeleteSchedule } from './useSchedules';
+export type { CreateScheduleInput, UpdateScheduleInput, ListSchedulesResponse, ExecutionHistoryItem, ExecutionHistoryResponse, TaskSchedule } from './useSchedules';
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/scheduling/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/scheduling/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC1C,YAAY,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAEvD,OAAO,EACL,gBAAgB,EAChB,cAAc,EACd,sBAAsB,EACtB,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,gBAAgB,CAAA;AACvB,YAAY,EACV,mBAAmB,EACnB,mBAAmB,EACnB,qBAAqB,EACrB,oBAAoB,EACpB,wBAAwB,EACxB,YAAY,EACb,MAAM,gBAAgB,CAAA"}

package/dist/hooks/scheduling/useSchedules.d.ts

@@ -0,0 +1,185 @@
+import type { TaskSchedule, TaskScheduleConfig, ExecutionHistoryItem, ExecutionHistoryResponse } from '@repo/core';
+import type { ListSchedulesFilters } from './queryKeys';
+export interface CreateScheduleInput {
+    name: string;
+    description?: string;
+    target: {
+        resourceType: 'agent' | 'workflow';
+        resourceId: string;
+    };
+    scheduleConfig: TaskScheduleConfig;
+    maxRetries?: number;
+    idempotencyKey?: string;
+    originExecutionId?: string;
+    originResourceType?: 'agent' | 'workflow' | 'scheduler' | 'api';
+    originResourceId?: string;
+}
+export interface UpdateScheduleInput {
+    id: string;
+    name?: string;
+    description?: string | null;
+    scheduleConfig?: TaskScheduleConfig;
+    maxRetries?: number;
+}
+/** List response using domain type for CC compatibility. */
+export interface ListSchedulesResponse {
+    schedules: TaskSchedule[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+/**
+ * List schedules with optional filters.
+ *
+ * @param filters - Optional filters for status, target resource, and pagination
+ * @returns TanStack Query result with schedules array and pagination info
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useListSchedules({ status: 'active', limit: 20 })
+ * ```
+ */
+export declare function useListSchedules(filters?: ListSchedulesFilters): import("@tanstack/react-query").UseQueryResult<ListSchedulesResponse, Error>;
+/**
+ * Get a single schedule by ID.
+ *
+ * @param id - Schedule UUID (undefined to disable query)
+ * @returns TanStack Query result with schedule data
+ *
+ * @example
+ * ```tsx
+ * const { data: schedule, isLoading } = useGetSchedule(scheduleId)
+ * ```
+ */
+export declare function useGetSchedule(id: string | undefined): import("@tanstack/react-query").UseQueryResult<TaskSchedule, Error>;
+/**
+ * Get execution history for a schedule.
+ *
+ * @param scheduleId - Schedule UUID (undefined to disable query)
+ * @param options - Pagination options (limit, offset)
+ * @returns TanStack Query result with execution history and pagination info
+ *
+ * @example
+ * ```tsx
+ * const { data } = useGetExecutionHistory(scheduleId, { limit: 10 })
+ * ```
+ */
+export declare function useGetExecutionHistory(scheduleId: string | undefined, options?: {
+    limit?: number;
+    offset?: number;
+}): import("@tanstack/react-query").UseQueryResult<{
+    executions: {
+        id: string;
+        createdAt: string;
+        status: "completed" | "failed" | "running" | "cancelled";
+        step: number | null;
+        itemLabel: string | null;
+        duration: number | null;
+        error: string | null;
+    }[];
+    total: number;
+    limit: number;
+    offset: number;
+}, Error>;
+/**
+ * Create a new schedule.
+ *
+ * @returns TanStack Mutation for creating schedules
+ *
+ * @example
+ * ```tsx
+ * const createSchedule = useCreateSchedule()
+ *
+ * createSchedule.mutate({
+ *   name: 'Daily Report',
+ *   target: { resourceType: 'workflow', resourceId: 'wf-123' },
+ *   scheduleConfig: { type: 'recurring', cron: '0 9 * * *', timezone: 'UTC', payload: {} }
+ * })
+ * ```
+ */
+export declare function useCreateSchedule(): import("@tanstack/react-query").UseMutationResult<TaskSchedule, Error, CreateScheduleInput, unknown>;
+/**
+ * Update schedule fields (name, description, scheduleConfig, maxRetries).
+ * Only active or paused schedules can be updated.
+ *
+ * @returns TanStack Mutation for updating schedules
+ *
+ * @example
+ * ```tsx
+ * const updateSchedule = useUpdateSchedule()
+ *
+ * updateSchedule.mutate({ id: 'schedule-123', name: 'Updated Name' })
+ * ```
+ */
+export declare function useUpdateSchedule(): import("@tanstack/react-query").UseMutationResult<TaskSchedule, Error, UpdateScheduleInput, unknown>;
+/**
+ * Update anchor datetime for relative schedules.
+ * Only applicable to schedules with type: 'relative'.
+ *
+ * @returns TanStack Mutation for updating schedule anchor
+ *
+ * @example
+ * ```tsx
+ * const updateAnchor = useUpdateAnchor()
+ *
+ * updateAnchor.mutate({ id: 'schedule-123', anchorAt: '2026-02-01T09:00:00Z' })
+ * ```
+ */
+export declare function useUpdateAnchor(): import("@tanstack/react-query").UseMutationResult<TaskSchedule, Error, {
+    id: string;
+    anchorAt: string;
+}, unknown>;
+/**
+ * Pause a schedule.
+ * Paused schedules will not execute until resumed.
+ *
+ * @returns TanStack Mutation for pausing schedules
+ *
+ * @example
+ * ```tsx
+ * const pauseSchedule = usePauseSchedule()
+ * pauseSchedule.mutate('schedule-123')
+ * ```
+ */
+export declare function usePauseSchedule(): import("@tanstack/react-query").UseMutationResult<TaskSchedule, Error, string, unknown>;
+/**
+ * Resume a paused schedule.
+ *
+ * @returns TanStack Mutation for resuming schedules
+ *
+ * @example
+ * ```tsx
+ * const resumeSchedule = useResumeSchedule()
+ * resumeSchedule.mutate('schedule-123')
+ * ```
+ */
+export declare function useResumeSchedule(): import("@tanstack/react-query").UseMutationResult<TaskSchedule, Error, string, unknown>;
+/**
+ * Cancel a schedule permanently (soft delete).
+ * Sets status to 'cancelled' -- schedule remains in DB for history.
+ * Cancelled schedules cannot be resumed.
+ *
+ * @returns TanStack Mutation for cancelling schedules
+ *
+ * @example
+ * ```tsx
+ * const cancelSchedule = useCancelSchedule()
+ * cancelSchedule.mutate('schedule-123')
+ * ```
+ */
+export declare function useCancelSchedule(): import("@tanstack/react-query").UseMutationResult<TaskSchedule, Error, string, unknown>;
+/**
+ * Delete a schedule permanently (hard delete).
+ * Removes schedule from database entirely.
+ *
+ * @returns TanStack Mutation for deleting schedules
+ *
+ * @example
+ * ```tsx
+ * const deleteSchedule = useDeleteSchedule()
+ * deleteSchedule.mutate('schedule-123')
+ * ```
+ */
+export declare function useDeleteSchedule(): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+export type { ExecutionHistoryItem, ExecutionHistoryResponse, TaskSchedule };
+//# sourceMappingURL=useSchedules.d.ts.map

package/dist/hooks/scheduling/useSchedules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSchedules.d.ts","sourceRoot":"","sources":["../../../src/hooks/scheduling/useSchedules.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAA;AAGlH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAMvD,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE;QACN,YAAY,EAAE,OAAO,GAAG,UAAU,CAAA;QAClC,UAAU,EAAE,MAAM,CAAA;KACnB,CAAA;IACD,cAAc,EAAE,kBAAkB,CAAA;IAClC,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,kBAAkB,CAAC,EAAE,OAAO,GAAG,UAAU,GAAG,WAAW,GAAG,KAAK,CAAA;IAC/D,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAC1B;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,cAAc,CAAC,EAAE,kBAAkB,CAAA;IACnC,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,4DAA4D;AAC5D,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,YAAY,EAAE,CAAA;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,CAAC,EAAE,oBAAoB,gFAoB9D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,uEAWpD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;;;;UAiBnH;AAMD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,yGAiBhC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,yGAqBhC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe;QAKgB,MAAM;cAAY,MAAM;YAgBtE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,4FAiB/B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,4FAiBhC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,4FAiBhC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,oFAchC;AAGD,YAAY,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,YAAY,EAAE,CAAA"}

package/dist/hooks/sessions/index.d.ts

@@ -0,0 +1,8 @@
+export * from './queryKeys';
+export * from './types';
+export * from './constants';
+export * from './useSessions';
+export * from './useSessionExecutions';
+export * from './useSessionMessages';
+export * from './useSessionWebSocket';
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/sessions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hooks/sessions/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,SAAS,CAAA;AACvB,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA;AAC7B,cAAc,wBAAwB,CAAA;AACtC,cAAc,sBAAsB,CAAA;AACpC,cAAc,uBAAuB,CAAA"}

package/dist/hooks/sessions/useSessionExecutions.d.ts

@@ -0,0 +1,13 @@
+import type { APIExecutionDetail } from '@repo/core';
+import type { SessionExecutionsResponse } from './types';
+/**
+ * Hook to fetch all executions for a session, grouped by turn.
+ * Each turn creates one execution.
+ */
+export declare function useSessionExecutions(sessionId: string): import("@tanstack/react-query").UseQueryResult<SessionExecutionsResponse, Error>;
+/**
+ * Hook to fetch a single execution detail for a session turn.
+ * Auto-refetches every 2 seconds while the execution is still running.
+ */
+export declare function useSessionExecution(sessionId: string, executionId: string): import("@tanstack/react-query").UseQueryResult<APIExecutionDetail, Error>;
+//# sourceMappingURL=useSessionExecutions.d.ts.map

package/dist/hooks/sessions/useSessionExecutions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSessionExecutions.d.ts","sourceRoot":"","sources":["../../../src/hooks/sessions/useSessionExecutions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAKpD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAA;AAExD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,oFAgBrD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,6EAoBzE"}

package/dist/hooks/sessions/useSessionMessages.d.ts

@@ -0,0 +1,7 @@
+import type { ChatMessage } from './types';
+/**
+ * Hook to fetch message history for a session.
+ * Transforms ISO date strings to Date objects on the returned messages.
+ */
+export declare function useSessionMessages(sessionId: string): import("@tanstack/react-query").UseQueryResult<ChatMessage[], Error>;
+//# sourceMappingURL=useSessionMessages.d.ts.map

package/dist/hooks/sessions/useSessionMessages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSessionMessages.d.ts","sourceRoot":"","sources":["../../../src/hooks/sessions/useSessionMessages.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAuB,MAAM,SAAS,CAAA;AAE/D;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,wEAuBnD"}

package/dist/hooks/sessions/useSessions.d.ts

@@ -0,0 +1,26 @@
+import type { CreateSessionResponse } from '../services/OperationsService';
+/**
+ * Hook to fetch sessions list with optional filtering.
+ */
+export declare function useSessions(params?: {
+    resourceId?: string;
+}, options?: {
+    enabled?: boolean;
+}): import("@tanstack/react-query").UseQueryResult<import("..").SessionListItem[], Error>;
+/**
+ * Hook to fetch a single session by ID.
+ */
+export declare function useSession(sessionId: string): import("@tanstack/react-query").UseQueryResult<import("@repo/core").SessionDTO, Error>;
+/**
+ * Hook to create a new session.
+ */
+export declare function useCreateSession(): import("@tanstack/react-query").UseMutationResult<CreateSessionResponse, Error, string, unknown>;
+/**
+ * Hook to delete a session.
+ */
+export declare function useDeleteSession(): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+/**
+ * Hook to archive a session.
+ */
+export declare function useArchiveSession(): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
+//# sourceMappingURL=useSessions.d.ts.map

package/dist/hooks/sessions/useSessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSessions.d.ts","sourceRoot":"","sources":["../../../src/hooks/sessions/useSessions.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAA;AAG1E;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,yFAa5F;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,0FAa3C;AAED;;GAEG;AACH,wBAAgB,gBAAgB,qGAe/B;AAED;;GAEG;AACH,wBAAgB,gBAAgB,oFAuB/B;AAED;;GAEG;AACH,wBAAgB,iBAAiB,oFAehC"}