@elevasis/ui 1.0.0

package/dist/chunk-WNWKOCGJ.js

@@ -0,0 +1,1067 @@
+import { UuidSchema, ResourceTypeSchema, NonEmptyStringSchema, OriginResourceTypeSchema } from './chunk-JKERRYVS.js';
+import { useElevasisServices } from './chunk-KA7LO7U5.js';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+import { z } from 'zod';
+
+// src/hooks/executions/queryKeys.ts
+var executionsKeys = {
+  all: ["executions"],
+  resources: (orgId) => [...executionsKeys.all, "resources", orgId],
+  resourceDefinition: (orgId, resourceId) => [...executionsKeys.all, "definition", orgId, resourceId],
+  // NOTE: resourceStatus and limit intentionally excluded from queryKey for unified cache invalidation.
+  // All filter variants share the same cache so SSE invalidations work across filters.
+  executions: (orgId, resourceId) => [...executionsKeys.all, "list", orgId, resourceId],
+  execution: (orgId, resourceId, executionId) => [...executionsKeys.all, "execution", orgId, resourceId, executionId]
+};
+function useExecutions(resourceId, resourceStatus, limit) {
+  const { apiRequest, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    // eslint-disable-next-line @tanstack/query/exhaustive-deps
+    queryKey: executionsKeys.executions(organizationId, resourceId),
+    queryFn: async () => {
+      const params = new URLSearchParams();
+      if (resourceStatus && resourceStatus !== "all") {
+        params.set("resourceStatus", resourceStatus);
+      }
+      if (limit) {
+        params.set("limit", String(limit));
+      }
+      const queryString = params.toString();
+      const endpoint = `/execution-engine/executions/${resourceId}${queryString ? `?${queryString}` : ""}`;
+      return apiRequest(endpoint);
+    },
+    enabled: isReady && !!resourceId
+  });
+}
+var REFETCH_INTERVAL_RUNNING = 2e3;
+function useExecution(resourceId, executionId) {
+  const { apiRequest, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: executionsKeys.execution(organizationId, resourceId, executionId),
+    queryFn: () => apiRequest(`/execution-engine/executions/${resourceId}/${executionId}`),
+    enabled: isReady && !!resourceId && !!executionId,
+    refetchInterval: (query) => {
+      const data = query.state.data;
+      return data?.status === "running" ? REFETCH_INTERVAL_RUNNING : false;
+    }
+  });
+}
+function useExecuteAsync() {
+  const { apiRequest, organizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ resourceId, resourceType, input }) => {
+      const response = await apiRequest("/execution-engine/execute-async", {
+        method: "POST",
+        body: JSON.stringify({ resourceType, resourceId, input })
+      });
+      return { ...response, resourceId };
+    },
+    onSuccess: (data) => {
+      queryClient.invalidateQueries({
+        queryKey: executionsKeys.executions(organizationId, data.resourceId)
+      });
+    }
+  });
+}
+function useRetryExecution() {
+  const { apiRequest, organizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ resourceId, resourceType, input }) => {
+      const response = await apiRequest("/execution-engine/execute-async", {
+        method: "POST",
+        body: JSON.stringify({ resourceType, resourceId, input })
+      });
+      return { ...response, resourceId };
+    },
+    onSuccess: (data) => {
+      queryClient.invalidateQueries({
+        queryKey: executionsKeys.executions(organizationId, data.resourceId)
+      });
+    }
+  });
+}
+function useCancelExecution() {
+  const { apiRequest, organizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ resourceId, executionId }) => {
+      const response = await apiRequest(
+        `/execution-engine/executions/${resourceId}/${executionId}/cancel`,
+        { method: "POST" }
+      );
+      return { ...response, resourceId, executionId };
+    },
+    onSuccess: (data) => {
+      queryClient.invalidateQueries({
+        queryKey: executionsKeys.execution(organizationId, data.resourceId, data.executionId)
+      });
+      queryClient.invalidateQueries({
+        queryKey: executionsKeys.executions(organizationId, data.resourceId)
+      });
+    }
+  });
+}
+function useDeleteExecution() {
+  const { apiRequest, organizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({ resourceId, executionId }) => {
+      await apiRequest(`/execution-engine/executions/${resourceId}/${executionId}`, {
+        method: "DELETE"
+      });
+      return { resourceId, executionId };
+    },
+    onSuccess: (data) => {
+      queryClient.removeQueries({
+        queryKey: executionsKeys.execution(organizationId, data.resourceId, data.executionId)
+      });
+      queryClient.invalidateQueries({
+        queryKey: executionsKeys.executions(organizationId, data.resourceId)
+      });
+    }
+  });
+}
+function useBulkDeleteExecutions() {
+  const { apiRequest, organizationId } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async ({
+      resourceId,
+      resourceStatus
+    }) => {
+      const params = new URLSearchParams();
+      if (resourceStatus && resourceStatus !== "all") {
+        params.set("resourceStatus", resourceStatus);
+      }
+      const queryString = params.toString();
+      const endpoint = `/execution-engine/executions/${resourceId}${queryString ? `?${queryString}` : ""}`;
+      const response = await apiRequest(
+        endpoint,
+        { method: "DELETE" }
+      );
+      return { resourceId, deletedCount: response.deletedCount, resourceStatus };
+    },
+    onSuccess: (data) => {
+      queryClient.invalidateQueries({
+        queryKey: executionsKeys.executions(organizationId, data.resourceId)
+      });
+    }
+  });
+}
+var SessionIdParamSchema = z.object({
+  sessionId: UuidSchema
+}).strict();
+z.object({
+  sessionId: UuidSchema,
+  executionId: UuidSchema
+}).strict();
+var CreateSessionSchema = z.object({
+  resourceId: z.string().min(1).max(100),
+  userId: UuidSchema.optional(),
+  metadata: z.any().optional()
+}).strict();
+z.object({
+  input: z.unknown().refine(
+    (val) => {
+      let text;
+      if (typeof val === "string") {
+        text = val;
+      } else if (val && typeof val === "object" && "message" in val) {
+        text = String(val.message);
+      } else {
+        text = JSON.stringify(val);
+      }
+      return text.length > 0 && text.length <= 1e5;
+    },
+    { message: "Input must be between 1 and 100,000 characters" }
+  ),
+  metadata: z.any().optional()
+}).strict();
+z.object({
+  userId: UuidSchema.optional(),
+  resourceId: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(100).default(20)
+}).strict();
+z.object({
+  type: z.literal("session:turn"),
+  input: z.unknown().refine(
+    (val) => {
+      let text;
+      if (typeof val === "string") {
+        text = val;
+      } else if (val && typeof val === "object" && "message" in val) {
+        text = String(val.message);
+      } else {
+        text = JSON.stringify(val) || "";
+      }
+      return text && text.length > 0 && text.length <= 1e5;
+    },
+    { message: "Input must be between 1 and 100,000 characters" }
+  )
+}).strict();
+
+// src/hooks/services/OperationsService.ts
+var OperationsService = class {
+  constructor(apiRequest) {
+    this.apiRequest = apiRequest;
+  }
+  /**
+   * Fetch all available Execution Engine resources
+   * Uses the unified /list-resources endpoint
+   */
+  async getResources() {
+    return this.apiRequest("/execution-engine/resources");
+  }
+  /**
+   * Get detailed workflow information
+   * Optional: For future detailed views
+   */
+  async getWorkflowDetails() {
+    return this.apiRequest("/execution-engine/workflows/details");
+  }
+  /**
+   * Get detailed agent information
+   * Optional: For future detailed views
+   */
+  async getAgentDetails() {
+    return this.apiRequest("/execution-engine/agents/details");
+  }
+  /**
+   * Get detailed pipeline information
+   * Optional: For future detailed views
+   */
+  async getPipelineDetails() {
+    return this.apiRequest("/execution-engine/pipelines/details");
+  }
+  /**
+   * Get resource definition (workflow steps, agent actions, pipeline stages, etc.)
+   */
+  async getResourceDefinition(resourceId) {
+    return this.apiRequest(`/execution-engine/resources/${resourceId}/definition`);
+  }
+  /**
+   * List sessions with optional filtering
+   */
+  async listSessions(params) {
+    const queryParams = new URLSearchParams();
+    if (params?.resourceId) queryParams.append("resourceId", params.resourceId);
+    const endpoint = queryParams.toString() ? `/sessions?${queryParams.toString()}` : "/sessions";
+    const response = await this.apiRequest(endpoint);
+    return response.sessions.map((session) => ({
+      sessionId: session.sessionId,
+      resourceId: session.resourceId,
+      turnCount: session.turnCount,
+      isEnded: session.isEnded,
+      createdAt: new Date(session.createdAt),
+      updatedAt: new Date(session.updatedAt)
+    }));
+  }
+  /**
+   * Get session details by ID
+   */
+  async getSession(sessionId) {
+    SessionIdParamSchema.parse({ sessionId });
+    const response = await this.apiRequest(`/sessions/${sessionId}`);
+    return {
+      sessionId: response.sessionId,
+      resourceId: response.resourceId,
+      organizationId: response.organizationId,
+      userId: response.userId || void 0,
+      turnCount: response.turnCount,
+      isEnded: response.isEnded,
+      metadata: response.metadata || void 0,
+      memorySnapshot: response.memorySnapshot || void 0,
+      createdAt: new Date(response.createdAt),
+      updatedAt: new Date(response.updatedAt),
+      endedAt: response.endedAt ? new Date(response.endedAt) : void 0
+    };
+  }
+  /**
+   * Create a new session for an agent
+   */
+  async createSession(resourceId) {
+    const validated = CreateSessionSchema.parse({
+      resourceId
+    });
+    const result = await this.apiRequest("/sessions", {
+      method: "POST",
+      body: JSON.stringify(validated)
+    });
+    return result;
+  }
+  /**
+   * Archive a session
+   */
+  async archiveSession(sessionId) {
+    SessionIdParamSchema.parse({ sessionId });
+    return this.apiRequest(`/sessions/${sessionId}/archive`, {
+      method: "POST"
+    });
+  }
+};
+function useResources() {
+  const { apiRequest, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: executionsKeys.resources(organizationId),
+    queryFn: async () => {
+      const service = new OperationsService(apiRequest);
+      const result = await service.getResources();
+      return {
+        workflows: result.workflows ?? [],
+        agents: result.agents ?? [],
+        pipelines: result.pipelines ?? [],
+        total: (result.workflows?.length ?? 0) + (result.agents?.length ?? 0) + (result.pipelines?.length ?? 0)
+      };
+    },
+    enabled: isReady
+  });
+}
+function useResourceDefinition(resourceId, enabled = true) {
+  const { apiRequest, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: executionsKeys.resourceDefinition(organizationId, resourceId),
+    queryFn: () => {
+      const service = new OperationsService(apiRequest);
+      return service.getResourceDefinition(resourceId);
+    },
+    enabled: enabled && isReady && !!resourceId,
+    retry: 2,
+    retryDelay: (attemptIndex) => Math.min(1e3 * 2 ** attemptIndex, 3e4)
+  });
+}
+function useActivityTrend(params = {}) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: ["activities", "trend", organizationId, params],
+    queryFn: async () => {
+      const queryParams = new URLSearchParams();
+      if (params.activityType) queryParams.set("activityType", params.activityType);
+      if (params.entityType) queryParams.set("entityType", params.entityType);
+      if (params.entityId) queryParams.set("entityId", params.entityId);
+      if (params.startDate) queryParams.set("startDate", params.startDate);
+      if (params.endDate) queryParams.set("endDate", params.endDate);
+      const queryString = queryParams.toString();
+      const endpoint = `/activities/trend${queryString ? `?${queryString}` : ""}`;
+      const response = await apiRequest(endpoint);
+      return {
+        timestamps: response.timestamps.map((t) => new Date(t)),
+        total: response.total
+      };
+    },
+    enabled: isReady,
+    refetchInterval: 3e4,
+    staleTime: 0
+  });
+}
+function useActivities(params = {}) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: ["activities", "list", organizationId, params],
+    queryFn: async () => {
+      const queryParams = new URLSearchParams();
+      if (params.limit) queryParams.set("limit", params.limit.toString());
+      if (params.offset) queryParams.set("offset", params.offset.toString());
+      if (params.activityType) queryParams.set("activityType", params.activityType);
+      if (params.entityType) queryParams.set("entityType", params.entityType);
+      if (params.entityId) queryParams.set("entityId", params.entityId);
+      if (params.startDate) queryParams.set("startDate", params.startDate);
+      if (params.endDate) queryParams.set("endDate", params.endDate);
+      if (params.status && params.status !== "all") queryParams.set("status", params.status);
+      if (params.search && params.search.trim()) queryParams.set("search", params.search.trim());
+      const queryString = queryParams.toString();
+      const endpoint = `/activities${queryString ? `?${queryString}` : ""}`;
+      const response = await apiRequest(endpoint);
+      return {
+        activities: response.activities.map((activity) => ({
+          ...activity,
+          occurredAt: new Date(activity.occurredAt),
+          createdAt: new Date(activity.createdAt)
+        })),
+        total: response.total
+      };
+    },
+    enabled: isReady,
+    refetchInterval: 3e4,
+    // 30s real-time polling
+    staleTime: 0
+    // Real-time data - always refetch on mount/org switch
+  });
+}
+function useExecutionLogs(params = {}) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: ["monitoring", "execution-logs", organizationId, params],
+    queryFn: async () => {
+      const queryParams = new URLSearchParams();
+      if (params.resourceId) queryParams.set("resourceId", params.resourceId);
+      if (params.status && params.status !== "all") queryParams.set("status", params.status);
+      if (params.resourceStatus && params.resourceStatus !== "all") queryParams.set("resourceStatus", params.resourceStatus);
+      if (params.startDate !== void 0) queryParams.set("startDate", params.startDate.toString());
+      if (params.endDate !== void 0) queryParams.set("endDate", params.endDate.toString());
+      if (params.limit !== void 0) queryParams.set("limit", params.limit.toString());
+      if (params.offset !== void 0) queryParams.set("offset", params.offset.toString());
+      const queryString = queryParams.toString();
+      const endpoint = `/execution-engine/executions${queryString ? `?${queryString}` : ""}`;
+      return apiRequest(endpoint);
+    },
+    enabled: isReady,
+    refetchInterval: 3e4,
+    // 30s real-time polling
+    staleTime: 0
+    // Real-time data - always refetch on mount/org switch
+  });
+}
+var RelativeScheduleItemSchema = z.object({
+  offset: z.string().regex(/^[+-]\d+[dhm]$/, "Invalid offset format. Use +3d, -2h, +30m, etc."),
+  payload: z.record(z.string(), z.unknown()),
+  label: z.string().optional()
+});
+var AbsoluteScheduleItemSchema = z.object({
+  runAt: z.string().datetime({ message: "Invalid datetime format" }),
+  payload: z.record(z.string(), z.unknown()),
+  label: z.string().optional()
+});
+var RecurringScheduleConfigSchema = z.object({
+  type: z.literal("recurring"),
+  cron: z.string().optional(),
+  interval: z.enum(["daily", "weekly", "monthly"]).optional(),
+  time: z.string().regex(/^\d{2}:\d{2}$/, "Time must be in HH:MM format").optional(),
+  timezone: z.string().min(1, "Timezone is required"),
+  payload: z.record(z.string(), z.unknown()),
+  endAt: z.string().datetime().nullable().optional(),
+  overduePolicy: z.enum(["skip", "execute"]).optional()
+}).refine((data) => data.cron || data.interval, { message: "Either cron or interval must be provided" });
+var RelativeScheduleConfigSchema = z.object({
+  type: z.literal("relative"),
+  anchorAt: z.string().datetime({ message: "Invalid anchor datetime" }),
+  anchorLabel: z.string().optional(),
+  items: z.array(RelativeScheduleItemSchema).min(1, "At least one item required"),
+  overduePolicy: z.enum(["skip", "execute"]).optional()
+});
+var AbsoluteScheduleConfigSchema = z.object({
+  type: z.literal("absolute"),
+  items: z.array(AbsoluteScheduleItemSchema).min(1, "At least one item required"),
+  overduePolicy: z.enum(["skip", "execute"]).optional()
+});
+var TaskScheduleConfigSchema = z.discriminatedUnion("type", [
+  RecurringScheduleConfigSchema,
+  RelativeScheduleConfigSchema,
+  AbsoluteScheduleConfigSchema
+]);
+var ScheduleTargetSchema = z.object({
+  resourceType: ResourceTypeSchema,
+  resourceId: NonEmptyStringSchema.max(255)
+});
+var OptionalOriginTrackingSchema = z.object({
+  originExecutionId: UuidSchema.optional(),
+  originResourceType: OriginResourceTypeSchema.optional(),
+  originResourceId: z.string().max(100).optional()
+});
+z.object({
+  organizationId: UuidSchema,
+  name: NonEmptyStringSchema.max(255),
+  description: z.string().max(1e3).optional(),
+  target: ScheduleTargetSchema,
+  scheduleConfig: TaskScheduleConfigSchema,
+  maxRetries: z.number().int().min(0).max(10).optional().default(3),
+  idempotencyKey: z.string().max(255).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+}).merge(OptionalOriginTrackingSchema);
+var CreateScheduleRequestSchema = z.object({
+  name: z.string().min(1, "Name is required").max(255),
+  description: z.string().max(1e3).optional(),
+  target: z.object({
+    resourceType: ResourceTypeSchema,
+    resourceId: z.string().min(1, "Resource ID is required").max(255)
+  }),
+  scheduleConfig: TaskScheduleConfigSchema,
+  maxRetries: z.number().int().min(0).max(10).optional(),
+  idempotencyKey: z.string().max(255).optional(),
+  // Origin tracking (optional)
+  originExecutionId: z.string().uuid().optional(),
+  originResourceType: OriginResourceTypeSchema.optional(),
+  originResourceId: z.string().max(255).optional()
+});
+z.object({
+  status: z.enum(["active", "paused", "completed", "cancelled"]).optional(),
+  targetResourceType: ResourceTypeSchema.optional(),
+  targetResourceId: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(100).optional().default(50),
+  offset: z.coerce.number().int().min(0).optional().default(0)
+});
+var GetScheduleParamsSchema = z.object({
+  id: z.string().uuid("Invalid schedule ID")
+});
+var UpdateAnchorRequestSchema = z.object({
+  anchorAt: z.string().datetime({ message: "Invalid anchor datetime format" })
+});
+var UpdateScheduleRequestSchema = z.object({
+  name: z.string().min(1, "Name cannot be empty").max(255).optional(),
+  description: z.string().max(1e3).nullable().optional(),
+  scheduleConfig: TaskScheduleConfigSchema.optional(),
+  maxRetries: z.number().int().min(0).max(10).optional()
+}).strict().refine(
+  (data) => data.name !== void 0 || data.description !== void 0 || data.scheduleConfig !== void 0 || data.maxRetries !== void 0,
+  { message: "At least one field (name, description, scheduleConfig, maxRetries) must be provided" }
+);
+z.object({
+  schedules: z.array(
+    z.object({
+      // Required identifiers
+      id: z.string().uuid(),
+      organization_id: z.string().uuid(),
+      name: z.string(),
+      // Target
+      target_resource_type: z.string(),
+      target_resource_id: z.string(),
+      // Schedule definition
+      schedule_config: z.record(z.string(), z.unknown()),
+      // JSONB from database
+      current_step: z.number().int(),
+      status: z.string(),
+      // Scheduling state
+      next_run_at: z.string().nullable(),
+      last_run_at: z.string().nullable(),
+      last_execution_id: z.string().uuid().nullable(),
+      // Config
+      max_retries: z.number().int(),
+      retry_count: z.number().int(),
+      idempotency_key: z.string().nullable(),
+      description: z.string().nullable(),
+      // Origin tracking
+      origin_execution_id: z.string().uuid().nullable(),
+      origin_resource_type: z.string().nullable(),
+      origin_resource_id: z.string().nullable(),
+      // Timestamps (PostgreSQL format with microseconds)
+      created_at: z.string(),
+      updated_at: z.string()
+    })
+  ).min(1).max(100)
+});
+z.object({
+  id: z.string().uuid("Invalid schedule ID")
+});
+z.object({
+  limit: z.coerce.number().int().min(1).max(100).optional().default(20),
+  offset: z.coerce.number().int().min(0).optional().default(0)
+});
+var ScheduleResponseSchema = z.object({
+  id: z.string().uuid(),
+  organizationId: z.string().uuid(),
+  name: z.string(),
+  description: z.string().nullable(),
+  target: z.object({
+    resourceType: ResourceTypeSchema,
+    resourceId: z.string()
+  }),
+  scheduleConfig: TaskScheduleConfigSchema,
+  nextRunAt: z.string().datetime().nullable(),
+  currentStep: z.number().int(),
+  status: z.enum(["active", "paused", "completed", "cancelled"]),
+  lastRunAt: z.string().datetime().nullable(),
+  lastExecutionId: z.string().uuid().nullable(),
+  maxRetries: z.number().int(),
+  idempotencyKey: z.string().nullable(),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime()
+});
+z.object({
+  schedules: z.array(ScheduleResponseSchema),
+  total: z.number().int(),
+  limit: z.number().int(),
+  offset: z.number().int()
+});
+var ExecutionHistoryItemSchema = z.object({
+  id: z.string().uuid(),
+  createdAt: z.string().datetime(),
+  status: z.enum(["running", "completed", "failed", "cancelled"]),
+  step: z.number().int().nullable(),
+  itemLabel: z.string().nullable(),
+  duration: z.number().nullable(),
+  // milliseconds
+  error: z.string().nullable()
+});
+z.object({
+  executions: z.array(ExecutionHistoryItemSchema),
+  total: z.number().int(),
+  limit: z.number().int(),
+  offset: z.number().int()
+});
+z.object({
+  processed: z.number().int(),
+  succeeded: z.number().int(),
+  failed: z.number().int(),
+  errors: z.array(
+    z.object({
+      scheduleId: z.string().uuid(),
+      error: z.string()
+    })
+  ).optional()
+});
+
+// ../core/src/operations/observability/utils.ts
+function getTimeRangeDates(range) {
+  const end = /* @__PURE__ */ new Date();
+  const start = /* @__PURE__ */ new Date();
+  switch (range) {
+    case "1h":
+      start.setHours(start.getHours() - 1);
+      break;
+    case "24h":
+      start.setHours(start.getHours() - 24);
+      break;
+    case "7d":
+      start.setDate(start.getDate() - 7);
+      break;
+    case "30d":
+      start.setDate(start.getDate() - 30);
+      break;
+  }
+  return {
+    startDate: start.toISOString(),
+    endDate: end.toISOString()
+  };
+}
+
+// src/hooks/monitoring/useCostSummary.ts
+function useCostSummary(timeRange) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: ["cost-analytics", "cost-summary", organizationId, timeRange],
+    queryFn: async () => {
+      const { startDate, endDate } = getTimeRangeDates(timeRange);
+      return apiRequest(
+        `/observability/cost-summary?startDate=${startDate}&endDate=${endDate}`
+      );
+    },
+    enabled: isReady,
+    refetchInterval: 6e4
+    // 60s dashboard polling
+  });
+}
+function useExecutionHealth({ timeRange }) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: ["monitoring", "execution-health", organizationId, timeRange],
+    queryFn: async () => {
+      const { startDate, endDate } = getTimeRangeDates(timeRange);
+      return apiRequest(
+        `/observability/dashboard?startDate=${startDate}&endDate=${endDate}`
+      );
+    },
+    enabled: isReady,
+    refetchInterval: 6e4,
+    // 60s dashboard polling
+    staleTime: 3e4
+    // 30s monitoring stale time
+  });
+}
+
+// src/hooks/observability/queryKeys.ts
+var observabilityKeys = {
+  all: ["observability"],
+  // Error analysis
+  errorAnalysis: (organizationId, timeRange) => [...observabilityKeys.all, "error-analysis", organizationId, timeRange],
+  // Error details list
+  errorDetails: (organizationId, filters) => [...observabilityKeys.all, "error-details", organizationId, filters],
+  // Single execution error detail
+  errorDetail: (organizationId, executionId) => [...observabilityKeys.all, "error-detail", organizationId, executionId],
+  // Error trends time-series
+  errorTrends: (organizationId, startDate, endDate, granularity) => [...observabilityKeys.all, "error-trends", organizationId, startDate, endDate, granularity],
+  // Error distribution breakdown
+  errorDistribution: (organizationId, startDate, endDate, groupBy) => [...observabilityKeys.all, "error-distribution", organizationId, startDate, endDate, groupBy],
+  // Top failing resources
+  topFailingResources: (organizationId, startDate, endDate, limit) => [...observabilityKeys.all, "top-failing-resources", organizationId, startDate, endDate, limit],
+  // Cost trends time-series
+  costTrends: (organizationId, timeRange, granularity) => [...observabilityKeys.all, "cost-trends", organizationId, timeRange, granularity],
+  // Cost by model breakdown
+  costByModel: (organizationId, timeRange) => [...observabilityKeys.all, "cost-by-model", organizationId, timeRange],
+  // Cost breakdown per resource/model
+  costBreakdown: (organizationId, timeRange) => [...observabilityKeys.all, "cost-breakdown", organizationId, timeRange],
+  // Composite dashboard metrics
+  dashboardMetrics: (organizationId, timeRange) => [...observabilityKeys.all, "dashboard-metrics", organizationId, timeRange],
+  // Business impact / automation ROI
+  businessImpact: (organizationId, timeRange) => [...observabilityKeys.all, "business-impact", organizationId, timeRange]
+};
+function useErrorAnalysis(timeRange) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: observabilityKeys.errorAnalysis(organizationId, timeRange),
+    queryFn: async () => {
+      const { startDate, endDate } = getTimeRangeDates(timeRange);
+      return apiRequest(`/observability/error-analysis?startDate=${startDate}&endDate=${endDate}`);
+    },
+    enabled: isReady,
+    refetchInterval: 6e4
+  });
+}
+function useErrorDetails(filters) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: observabilityKeys.errorDetails(organizationId, filters),
+    queryFn: async () => {
+      const params = new URLSearchParams();
+      if (filters.errorType) params.append("errorType", filters.errorType);
+      if (filters.severity) params.append("severity", filters.severity);
+      if (filters.search) params.append("search", filters.search);
+      if (filters.startDate) params.append("startDate", filters.startDate);
+      if (filters.endDate) params.append("endDate", filters.endDate);
+      if (filters.page) params.append("page", filters.page.toString());
+      if (filters.limit) params.append("limit", filters.limit.toString());
+      if (filters.resolved !== void 0) params.append("resolved", filters.resolved.toString());
+      const queryString = params.toString();
+      const endpoint = `/observability/error-details${queryString ? `?${queryString}` : ""}`;
+      return apiRequest(endpoint);
+    },
+    enabled: isReady,
+    refetchInterval: 6e4,
+    staleTime: 3e4
+  });
+}
+function useErrorDetail(executionId) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: observabilityKeys.errorDetail(organizationId, executionId),
+    queryFn: async () => {
+      if (!executionId) return null;
+      const response = await apiRequest(`/observability/error-details/${executionId}`);
+      return response.errors;
+    },
+    enabled: !!executionId && isReady,
+    staleTime: 3e4
+  });
+}
+function useErrorTrends({ startDate, endDate, granularity }) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: observabilityKeys.errorTrends(organizationId, startDate, endDate, granularity),
+    queryFn: async () => {
+      const params = new URLSearchParams({ startDate, endDate, granularity });
+      return apiRequest(`/observability/error-analytics/trends?${params.toString()}`);
+    },
+    enabled: isReady,
+    refetchInterval: 6e4,
+    staleTime: 3e4
+  });
+}
+function useErrorDistribution({ startDate, endDate, groupBy }) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: observabilityKeys.errorDistribution(organizationId, startDate, endDate, groupBy),
+    queryFn: async () => {
+      const params = new URLSearchParams({ startDate, endDate, groupBy });
+      return apiRequest(`/observability/error-analytics/distribution?${params.toString()}`);
+    },
+    enabled: isReady,
+    refetchInterval: 6e4,
+    staleTime: 3e4
+  });
+}
+function useTopFailingResources({ startDate, endDate, limit = 10 }) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: observabilityKeys.topFailingResources(organizationId, startDate, endDate, limit),
+    queryFn: async () => {
+      const params = new URLSearchParams({ startDate, endDate, limit: String(limit) });
+      return apiRequest(`/observability/error-analytics/top-resources?${params.toString()}`);
+    },
+    enabled: isReady,
+    refetchInterval: 6e4,
+    staleTime: 3e4
+  });
+}
+function useResolveError() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (errorId) => {
+      return apiRequest(`/observability/error-details/${errorId}/resolve`, { method: "PATCH" });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: observabilityKeys.all });
+    }
+  });
+}
+function useUnresolveError() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (errorId) => {
+      return apiRequest(`/observability/error-details/${errorId}/unresolve`, { method: "PATCH" });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: observabilityKeys.all });
+    }
+  });
+}
+function useResolveAllErrors() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async () => {
+      return apiRequest("/observability/error-details/resolve-all", { method: "PATCH" });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: observabilityKeys.all });
+    }
+  });
+}
+function useResolveErrorsByExecution() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (executionId) => {
+      return apiRequest(`/observability/error-details/execution/${executionId}/resolve`, { method: "PATCH" });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: observabilityKeys.all });
+    }
+  });
+}
+function useCostTrends(timeRange, granularity = "day") {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: observabilityKeys.costTrends(organizationId, timeRange, granularity),
+    queryFn: async () => {
+      const { startDate, endDate } = getTimeRangeDates(timeRange);
+      const params = new URLSearchParams({ startDate, endDate, granularity });
+      return apiRequest(`/observability/cost-trends?${params.toString()}`);
+    },
+    enabled: isReady,
+    refetchInterval: 6e4
+  });
+}
+function useCostByModel(timeRange) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: observabilityKeys.costByModel(organizationId, timeRange),
+    queryFn: async () => {
+      const { startDate, endDate } = getTimeRangeDates(timeRange);
+      const params = new URLSearchParams({ startDate, endDate });
+      return apiRequest(`/observability/cost-by-model?${params.toString()}`);
+    },
+    enabled: isReady,
+    refetchInterval: 6e4
+  });
+}
+function useCostBreakdown(timeRange) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: observabilityKeys.costBreakdown(organizationId, timeRange),
+    queryFn: async () => {
+      const { startDate, endDate } = getTimeRangeDates(timeRange);
+      const params = new URLSearchParams({ startDate, endDate });
+      return apiRequest(`/observability/cost-breakdown?${params.toString()}`);
+    },
+    enabled: isReady,
+    refetchInterval: 6e4
+  });
+}
+function useDashboardMetrics(timeRange) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: observabilityKeys.dashboardMetrics(organizationId, timeRange),
+    queryFn: async () => {
+      const { startDate, endDate } = getTimeRangeDates(timeRange);
+      const params = new URLSearchParams({ startDate, endDate });
+      return apiRequest(`/observability/dashboard?${params.toString()}`);
+    },
+    enabled: isReady,
+    refetchInterval: 6e4
+  });
+}
+function useBusinessImpact(timeRange) {
+  const { apiRequest, isReady, organizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: observabilityKeys.businessImpact(organizationId, timeRange),
+    queryFn: async () => {
+      const { startDate, endDate } = getTimeRangeDates(timeRange);
+      const params = new URLSearchParams({ startDate, endDate });
+      return apiRequest(`/observability/business-impact?${params.toString()}`);
+    },
+    enabled: isReady,
+    refetchInterval: 6e4
+  });
+}
+
+// src/hooks/scheduling/queryKeys.ts
+var scheduleKeys = {
+  all: (orgId) => ["schedules", orgId],
+  lists: (orgId) => [...scheduleKeys.all(orgId), "list"],
+  list: (orgId, filters) => [...scheduleKeys.lists(orgId), filters],
+  details: (orgId) => [...scheduleKeys.all(orgId), "detail"],
+  detail: (orgId, id) => [...scheduleKeys.details(orgId), id],
+  executions: (orgId, id) => [...scheduleKeys.detail(orgId, id), "executions"]
+};
+function useListSchedules(filters) {
+  const { apiRequest, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: scheduleKeys.list(organizationId, filters),
+    queryFn: async () => {
+      const params = new URLSearchParams();
+      if (filters?.status) params.set("status", filters.status);
+      if (filters?.targetResourceType) params.set("targetResourceType", filters.targetResourceType);
+      if (filters?.targetResourceId) params.set("targetResourceId", filters.targetResourceId);
+      if (filters?.limit) params.set("limit", String(filters.limit));
+      if (filters?.offset) params.set("offset", String(filters.offset));
+      const queryString = params.toString();
+      const endpoint = `/task-scheduler/schedules${queryString ? `?${queryString}` : ""}`;
+      return apiRequest(endpoint);
+    },
+    enabled: isReady
+  });
+}
+function useGetSchedule(id) {
+  const { apiRequest, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: scheduleKeys.detail(organizationId, id),
+    queryFn: async () => {
+      const data = await apiRequest(`/task-scheduler/schedules/${id}`);
+      return data.schedule;
+    },
+    enabled: isReady && !!id
+  });
+}
+function useGetExecutionHistory(scheduleId, options) {
+  const { apiRequest, organizationId, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: [...scheduleKeys.executions(organizationId, scheduleId), options?.limit, options?.offset],
+    queryFn: async () => {
+      const params = new URLSearchParams();
+      if (options?.limit) params.set("limit", String(options.limit));
+      if (options?.offset) params.set("offset", String(options.offset));
+      const queryString = params.toString();
+      const endpoint = `/task-scheduler/schedules/${scheduleId}/executions${queryString ? `?${queryString}` : ""}`;
+      return apiRequest(endpoint);
+    },
+    enabled: isReady && !!scheduleId
+  });
+}
+function useCreateSchedule() {
+  const queryClient = useQueryClient();
+  const { apiRequest, organizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async (input) => {
+      const validated = CreateScheduleRequestSchema.parse(input);
+      const data = await apiRequest("/task-scheduler/schedules", {
+        method: "POST",
+        body: JSON.stringify(validated)
+      });
+      return data.schedule;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(organizationId) });
+    }
+  });
+}
+function useUpdateSchedule() {
+  const queryClient = useQueryClient();
+  const { apiRequest, organizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async ({ id, ...fields }) => {
+      GetScheduleParamsSchema.parse({ id });
+      const validated = UpdateScheduleRequestSchema.parse(fields);
+      const data = await apiRequest(`/task-scheduler/schedules/${id}`, {
+        method: "PATCH",
+        body: JSON.stringify(validated)
+      });
+      return data.schedule;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: scheduleKeys.detail(organizationId, variables.id)
+      });
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(organizationId) });
+    }
+  });
+}
+function useUpdateAnchor() {
+  const queryClient = useQueryClient();
+  const { apiRequest, organizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async ({ id, anchorAt }) => {
+      GetScheduleParamsSchema.parse({ id });
+      UpdateAnchorRequestSchema.parse({ anchorAt });
+      const data = await apiRequest(`/task-scheduler/schedules/${id}/anchor`, {
+        method: "PATCH",
+        body: JSON.stringify({ anchorAt })
+      });
+      return data.schedule;
+    },
+    onSuccess: (_, variables) => {
+      queryClient.invalidateQueries({
+        queryKey: scheduleKeys.detail(organizationId, variables.id)
+      });
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(organizationId) });
+    }
+  });
+}
+function usePauseSchedule() {
+  const queryClient = useQueryClient();
+  const { apiRequest, organizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async (id) => {
+      GetScheduleParamsSchema.parse({ id });
+      const data = await apiRequest(`/task-scheduler/schedules/${id}/pause`, {
+        method: "POST"
+      });
+      return data.schedule;
+    },
+    onSuccess: (_, id) => {
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.detail(organizationId, id) });
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(organizationId) });
+    }
+  });
+}
+function useResumeSchedule() {
+  const queryClient = useQueryClient();
+  const { apiRequest, organizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async (id) => {
+      GetScheduleParamsSchema.parse({ id });
+      const data = await apiRequest(`/task-scheduler/schedules/${id}/resume`, {
+        method: "POST"
+      });
+      return data.schedule;
+    },
+    onSuccess: (_, id) => {
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.detail(organizationId, id) });
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(organizationId) });
+    }
+  });
+}
+function useCancelSchedule() {
+  const queryClient = useQueryClient();
+  const { apiRequest, organizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async (id) => {
+      GetScheduleParamsSchema.parse({ id });
+      const data = await apiRequest(`/task-scheduler/schedules/${id}/cancel`, {
+        method: "POST"
+      });
+      return data.schedule;
+    },
+    onSuccess: (_, id) => {
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.detail(organizationId, id) });
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(organizationId) });
+    }
+  });
+}
+function useDeleteSchedule() {
+  const queryClient = useQueryClient();
+  const { apiRequest, organizationId } = useElevasisServices();
+  return useMutation({
+    mutationFn: async (id) => {
+      GetScheduleParamsSchema.parse({ id });
+      await apiRequest(`/task-scheduler/schedules/${id}`, { method: "DELETE" });
+    },
+    onSuccess: (_, id) => {
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.detail(organizationId, id) });
+      queryClient.invalidateQueries({ queryKey: scheduleKeys.lists(organizationId) });
+    }
+  });
+}
+
+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 };